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

Capture

Resolve and place these values directly in the scheduled prompt:

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:

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:

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

---
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.