Use this as a thin scheduling composition over oracle, loop,
orchestration, run, and verify. Invoke a required skill through the Skill
tool when its path is selected; mentioning a name in prose does not load its
instructions. For both immediate reroutes and the future job, stop and report the
blocker if a required skill is unavailable, denied, fails, or returns no usable
result. Never substitute ad hoc local behavior. Do not reproduce PackX or Oracle
mechanics here; oracle owns them at fire time.
oracle through the Skill tool.oracle-execute through the Skill tool.loop through
the Skill tool.orchestration through the Skill tool.Resolve and place these values directly in the scheduled prompt:
cwd: absolute working directory to inspect at fire time.repo_guard: when Git is present, capture repository root/identity and the exact
intended branch or worktree. Use none for a non-repository task.question: exact self-contained question Oracle must answer.conversation_anchor: a privacy-reviewed summary of requirements, decisions,
blockers, and evidence needed later; use none when repository state is enough.approved_post_actions: one ordered chain: [report], [report, verify] for a
pre-existing target, or [report, implement, verify]. An implementation is
never complete without applicable final proof. Default to [report].implementation_scope: for a chain containing implement, capture the allowed
paths or components, required outcome, and explicit limits. Use none otherwise.verification_target: when verify is approved without implement, capture the
exact pre-existing change, artifact, command surface, or acceptance target to
verify. Otherwise use post_consult_implementation or none.git_authorization: one of none, commit_new_diff,
commit_and_push_new_diff, or push_existing_commit. For a new diff, capture
exact branch, bounded scope, and named proof gate; also capture the exact remote
and destination ref for a push. For an existing commit, capture exact SHA,
branch, remote, destination ref, and proof gate. Default to none.Infer obvious values from the request and current directory. Ask only for an ambiguous future time, missing question, unsafe directory, unclear anchor, or contradictory actions. Never infer implementation, commit, or push approval. Commit and push remain separate permissions.
Validate the action tuple before scheduling:
report
is always first; every implement is followed by verify, and verify follows
the target it judges.implement requires a bounded implementation_scope. Oracle advice outside
that scope is report-only and requires fresh approval.verify without implement requires an exact verification_target; reject a
verify-only job that leaves the future agent to guess what to prove.commit_new_diff requires implement, verify, a named proof gate, an exact
branch, bounded scope, and commit authorization.commit_and_push_new_diff requires implement, verify, a named proof gate,
an exact branch, bounded scope, an exact remote and destination ref, and separate
commit and push authorization.push_existing_commit requires an exact existing commit SHA, branch, remote,
destination ref, named proof gate, and push authorization; it does not require
implement.repo_guard with repository identity and
branch/worktree. Push-capable authorizations additionally require the exact
remote and destination ref; commit-only authorization does not.CronCreate.Do not schedule raw or future conversation extraction. The anchor is the only conversation content carried forward. This avoids capturing unrelated turns added after scheduling and works across agent hosts.
CronCreate once with the captured prompt and recurring: false.:00 or :30 may fire up to 90 seconds early; reject that placement when the
requested time is a strict authorization or release boundary. Use a durable
scheduler when unattended execution must survive the session.Use a prompt with this contract:
Run exactly one scheduled Oracle consultation pipeline now.
Captured request:
- cwd: {absolute path}
- repo_guard: {repository identity, root, branch/worktree|none}
- question: {self-contained question}
- conversation_anchor: {privacy-reviewed anchor|none}
- approved_post_actions: {one allowed ordered chain}
- implementation_scope: {allowed paths/components, outcome, and limits|none}
- verification_target: {exact pre-existing target|post_consult_implementation|none}
- git_authorization: {none|commit_new_diff branch, scope, and proof details|commit_and_push_new_diff branch, scope, remote, destination ref, and proof details|push_existing_commit SHA, branch, remote, destination ref, and proof details}
At fire time:
1. Work from the captured cwd. If it no longer exists, stop and report the
blocker; do not reschedule automatically.
2. Inspect current repository instructions and relevant source. When Git is
present, verify repo_guard, then snapshot baseline HEAD, status, and diff before
any edit. Stop on repository or branch/worktree mismatch. Preserve every
pre-existing change and do not trust a bundle or plan prepared earlier.
3. Invoke `oracle` once through the Skill tool. Include the conversation
anchor as a small evidence supplement when it is not none. Let the oracle skill own
PackX, Oracle, blocking, reattachment, and output-log mechanics. Stop if the
skill cannot be loaded.
4. Run one consultation pipeline only. Mechanical reattachment or recovery owned
by the oracle skill is allowed, but do not ask a second Oracle question.
5. After the full answer is available, perform the captured chain in order:
- report: summarize the answer and identify the Oracle session slug.
- implement: edit only within implementation_scope. Treat advice outside it as
a recommendation requiring fresh approval.
- verify: verify exactly the captured verification_target. For runtime proof,
invoke `verify` through the Skill tool and invoke `run` through the Skill tool
only when the real surface must be launched and driven. Respect the invoked
verify skill's SKIP boundary when no runtime surface exists. If required proof
fails, fix only within scope and rerun; otherwise stop incomplete and perform
no Git action.
6. Git actions require a valid captured git_authorization tuple. Compare current
state with the fire-time baseline and isolate only this run's delta. Never stage
pre-existing files or hunks; if same-file overlap cannot be isolated safely,
abort the Git action. Recheck repo_guard, inspect the exact diff or commit, and
require the named proof gate to pass. Abort on identity, branch, scope, or
baseline drift, conflicts, failed proof, force-push need, or an unapproved
public-release implication.
7. For commit_new_diff, commit only the bounded verified run delta. For
commit_and_push_new_diff, do the same and push only the exact resulting commit
to the captured remote and destination ref without force. For
push_existing_commit, require the captured branch tip and exact push source to
resolve to the captured SHA, then push exactly `{SHA}:{captured_destination_ref}`
to the captured remote without force. Do not publish descendants merely because
they contain the approved SHA. Otherwise report the exact diff or SHA, branch,
remote, destination ref, and proof and request fresh approval.
8. If any unapproved action becomes desirable, report it instead of performing it.
---
name: oracle-schedule
description: >-
Use when the user asks to schedule exactly one Oracle/PackX consultation for a
specific future time, with repository context rebuilt when the job fires.
Capture the working directory, question, a privacy-reviewed conversation
anchor, and only explicitly approved linear post-consult actions. Do not use
for immediate Oracle work, recurring consultations, parallel workers, task
DAGs, or ordinary reminders; route those to oracle or
oracle-execute, loop, orchestration, or built-in scheduling.
---
# Oracle Follow-up
Use this as a thin scheduling composition over `oracle`, `loop`,
`orchestration`, `run`, and `verify`. Invoke a required skill through the Skill
tool when its path is selected; mentioning a name in prose does not load its
instructions. For both immediate reroutes and the future job, stop and report the
blocker if a required skill is unavailable, denied, fails, or returns no usable
result. Never substitute ad hoc local behavior. Do not reproduce PackX or Oracle
mechanics here; `oracle` owns them at fire time.
## Route Before Scheduling
- Immediate consult only: invoke `oracle` through the Skill tool.
- Immediate consult followed by local implementation: invoke
`oracle-execute` through the Skill tool.
- Repeating, periodic, polling, or "keep checking" request: invoke `loop` through
the Skill tool.
- Parallel workers, branching dependencies, supervised ownership, or decision
gates: invoke `orchestration` through the Skill tool.
- A finite linear sequence performed by the same future agent, such as consult,
implement, then verify, may remain in this skill.
- No future Oracle consult: use ordinary built-in scheduling.
## Capture
Resolve and place these values directly in the scheduled prompt:
- `cwd`: absolute working directory to inspect at fire time.
- `repo_guard`: when Git is present, capture repository root/identity and the exact
intended branch or worktree. Use `none` for a non-repository task.
- `question`: exact self-contained question Oracle must answer.
- `conversation_anchor`: a privacy-reviewed summary of requirements, decisions,
blockers, and evidence needed later; use `none` when repository state is enough.
- `approved_post_actions`: one ordered chain: `[report]`, `[report, verify]` for a
pre-existing target, or `[report, implement, verify]`. An implementation is
never complete without applicable final proof. Default to `[report]`.
- `implementation_scope`: for a chain containing `implement`, capture the allowed
paths or components, required outcome, and explicit limits. Use `none` otherwise.
- `verification_target`: when `verify` is approved without `implement`, capture the
exact pre-existing change, artifact, command surface, or acceptance target to
verify. Otherwise use `post_consult_implementation` or `none`.
- `git_authorization`: one of `none`, `commit_new_diff`,
`commit_and_push_new_diff`, or `push_existing_commit`. For a new diff, capture
exact branch, bounded scope, and named proof gate; also capture the exact remote
and destination ref for a push. For an existing commit, capture exact SHA,
branch, remote, destination ref, and proof gate. Default to `none`.
Infer obvious values from the request and current directory. Ask only for an
ambiguous future time, missing question, unsafe directory, unclear anchor, or
contradictory actions. Never infer implementation, commit, or push approval.
Commit and push remain separate permissions.
Validate the action tuple before scheduling:
- Reject an unordered list or any chain outside the three allowed chains. `report`
is always first; every `implement` is followed by `verify`, and `verify` follows
the target it judges.
- `implement` requires a bounded `implementation_scope`. Oracle advice outside
that scope is report-only and requires fresh approval.
- `verify` without `implement` requires an exact `verification_target`; reject a
verify-only job that leaves the future agent to guess what to prove.
- `commit_new_diff` requires `implement`, `verify`, a named proof gate, an exact
branch, bounded scope, and commit authorization.
- `commit_and_push_new_diff` requires `implement`, `verify`, a named proof gate,
an exact branch, bounded scope, an exact remote and destination ref, and separate
commit and push authorization.
- `push_existing_commit` requires an exact existing commit SHA, branch, remote,
destination ref, named proof gate, and push authorization; it does not require
`implement`.
- Every Git action requires a matching `repo_guard` with repository identity and
branch/worktree. Push-capable authorizations additionally require the exact
remote and destination ref; commit-only authorization does not.
- Reject every incompatible or incomplete tuple before calling `CronCreate`.
Do not schedule raw or future conversation extraction. The anchor is the only
conversation content carried forward. This avoids capturing unrelated turns
added after scheduling and works across agent hosts.
## Schedule Exactly Once
1. Resolve a specific future timestamp in the user's local timezone.
2. Convert it to a five-field cron expression with pinned minute, hour, day of
month, and month.
3. Confirm that the requested timestamp is the scheduler's next occurrence for
that expression. If an earlier yearly match would fire first, do not schedule;
report that the date is not representable by this one-shot scheduler.
4. Do not run PackX, create a bundle, call Oracle, stage context, or implement now.
5. Call `CronCreate` once with the captured prompt and `recurring: false`.
6. Do not execute the consult immediately and do not create a second job.
7. Report the scheduled local time, job ID, captured actions, Git authorization,
and lifecycle: the job fires only while this session is running and idle, may
pause on inherited permission requirements, is deleted when the session exits,
and cannot catch up after that deletion. Disclose that a one-shot on exact
`:00` or `:30` may fire up to 90 seconds early; reject that placement when the
requested time is a strict authorization or release boundary. Use a durable
scheduler when unattended execution must survive the session.
## Scheduled Prompt
Use a prompt with this contract:
```text
Run exactly one scheduled Oracle consultation pipeline now.
Captured request:
- cwd: {absolute path}
- repo_guard: {repository identity, root, branch/worktree|none}
- question: {self-contained question}
- conversation_anchor: {privacy-reviewed anchor|none}
- approved_post_actions: {one allowed ordered chain}
- implementation_scope: {allowed paths/components, outcome, and limits|none}
- verification_target: {exact pre-existing target|post_consult_implementation|none}
- git_authorization: {none|commit_new_diff branch, scope, and proof details|commit_and_push_new_diff branch, scope, remote, destination ref, and proof details|push_existing_commit SHA, branch, remote, destination ref, and proof details}
At fire time:
1. Work from the captured cwd. If it no longer exists, stop and report the
blocker; do not reschedule automatically.
2. Inspect current repository instructions and relevant source. When Git is
present, verify repo_guard, then snapshot baseline HEAD, status, and diff before
any edit. Stop on repository or branch/worktree mismatch. Preserve every
pre-existing change and do not trust a bundle or plan prepared earlier.
3. Invoke `oracle` once through the Skill tool. Include the conversation
anchor as a small evidence supplement when it is not none. Let the oracle skill own
PackX, Oracle, blocking, reattachment, and output-log mechanics. Stop if the
skill cannot be loaded.
4. Run one consultation pipeline only. Mechanical reattachment or recovery owned
by the oracle skill is allowed, but do not ask a second Oracle question.
5. After the full answer is available, perform the captured chain in order:
- report: summarize the answer and identify the Oracle session slug.
- implement: edit only within implementation_scope. Treat advice outside it as
a recommendation requiring fresh approval.
- verify: verify exactly the captured verification_target. For runtime proof,
invoke `verify` through the Skill tool and invoke `run` through the Skill tool
only when the real surface must be launched and driven. Respect the invoked
verify skill's SKIP boundary when no runtime surface exists. If required proof
fails, fix only within scope and rerun; otherwise stop incomplete and perform
no Git action.
6. Git actions require a valid captured git_authorization tuple. Compare current
state with the fire-time baseline and isolate only this run's delta. Never stage
pre-existing files or hunks; if same-file overlap cannot be isolated safely,
abort the Git action. Recheck repo_guard, inspect the exact diff or commit, and
require the named proof gate to pass. Abort on identity, branch, scope, or
baseline drift, conflicts, failed proof, force-push need, or an unapproved
public-release implication.
7. For commit_new_diff, commit only the bounded verified run delta. For
commit_and_push_new_diff, do the same and push only the exact resulting commit
to the captured remote and destination ref without force. For
push_existing_commit, require the captured branch tip and exact push source to
resolve to the captured SHA, then push exactly `{SHA}:{captured_destination_ref}`
to the captured remote without force. Do not publish descendants merely because
they contain the approved SHA. Otherwise report the exact diff or SHA, branch,
remote, destination ref, and proof and request fresh approval.
8. If any unapproved action becomes desirable, report it instead of performing it.
```
## Boundaries
- Never prebuild future PackX bundles, transcript supplements, plans, or edits.
- Never schedule recurrence or turn one consult into an Oracle loop.
- Never attach an evolving conversation transcript; use only the captured anchor.
- Never perform post-actions outside the captured list.
- Never treat advance Git authorization as permission for scope drift, another
branch, failed verification, deployment, publication, or force push.
- Never include secrets or unrelated private conversation content in the anchor.