vacation

The law this skill runs on: autonomy is safe only in proportion to reversibility and the ability to ask. /nightshift works one night while you sleep, branch-only, and never asks — it just does the safe work and leaves a brief. vacation is for the weeks you're on the road and not building 16/7: it runs itself on a schedule, takes on bigger and more ambiguous work, and opens PRs you review whenever you check in. The thing that licenses that extra autonomy is an async escape valve — when it hits a real decision it can't make safely, it texts you through your always-on agent, parks that one task, and keeps building everything else. It accumulates reviewable capital while you're gone; it never commits irreversible change you can't undo from a campsite.

Three hard invariants:

• The irreversibility floor is absolute — opening a PR is the ceiling. More autonomy means larger and more ambiguous work and OPENING PRs (reviewable, revertible), never merging, deploying, pushing to prod/main, posting publicly, touching secrets, or any irreversible or outward-facing act. You are away and cannot fast-correct, so the floor IS the safety. (Inherits /nightshift's contract and tightens it — the only thing added is "open the PR," nothing past it.)
• Escalate, don't guess — the async human channel is what buys the autonomy. On a genuinely consequential or ambiguous fork (a product decision, a real tradeoff, anything where guessing wrong wastes the trip), it posts ONE crisp question to you via your agent, parks that task as awaiting-decision, and continues other independent work. Never guess a consequential fork; never block the whole shift on one open question; never spam (batch questions, ~a digest per cycle).
• Bounded, reviewable, killable. Every cycle runs under a token/time budget; the vacation has a start/end window; a single text from you ("pause"/"stop vacation") halts it. Output is always a reviewable PR, never merged risk — inspectable capital, not committed change.

/vacation start (arm it)

1. Pin the window + cadence + budget. Confirm: until when (the vacation end date), how often a cycle runs (default daily), and a per-cycle token/time cap. Default CONSERVATIVE — short window, tight cap, escalate liberally — and widen on the next vacation as trust builds.
2. Schedule the recurring run. Delegate to /schedule (or the project's cron) to fire /vacation run on the cadence as a scheduled cloud agent. Do NOT re-roll cron.
3. Verify the escape valve before relying on it. The cloud run reaches you through your agent's broker (an ask_owner/get_owner_answers pair on a bearer-auth'd endpoint), so start must confirm THAT endpoint answers a round-trip — not just the raw message send. (Verify the delivery leg and the broker pair separately; the broker that exposes delivery to a credential-less cloud run is the usual unbuilt piece.) An escalation channel you didn't prove works end-to-end is the false-CLEAN trap (a guess engine with a dead phone line).
4. Restate the contract + the worklist source. Confirm the irreversibility floor, point the runs at the active PRD(s) + backlog as the primary worklist (per the build-not-tidy lesson: build features, don't only scout loose ends), and write the vacation config (window, cadence, budget, channel, worklist sources).

/vacation run (the scheduled cycle — the core)

Runs as a scheduled cloud agent on a FRESH checkout with NEITHER your server's volume NOR your messaging secrets. Placement triad: TRIGGERS on the /schedule cron; FILESYSTEM is a fresh clone, so it pushes branches + opens PRs on GitHub (never relies on local state); the escalation channel is BROKERED through your agent's authenticated endpoint — the agent (in-container, owning the volume + the messaging creds) does the actual send and the actual reply-read, so vacation NEVER ssh's, reads chat logs, or holds messaging creds itself (the placement-triad trap: the cloud run cannot reach the volume). It needs only one API token (the broker bearer) + the GitHub token in its env. CONSUMER is your GitHub PR review + your phone.

1. Resume parked decisions first. Fetch your answers to prior-cycle questions from your agent's endpoint (get_owner_answers — the agent reads its chat log in-container and matches replies to the pending question ids); unblock and queue those tasks ahead of new work.
2. Build the worklist (reuse /nightshift's scout engine — do not re-roll it): PRD features and the explicit backlog FIRST, loose-ends only if the feature work is dry. Score by value × safety × fits-in-one-cycle; drop anything that can't finish reviewably this cycle.
3. Execute under the floor. Each unit on its own branch; tests green; an adversarial /code-review pass that tries to refute the change; then open ONE cohesive PR per finished unit, described plainly (what changed, what's verified with real output, what's still open), linked to its PRD feature.
4. Escalate, don't guess. On a real fork, post a crisp question via your agent's endpoint (ask_owner — the agent does the send in-container; the cloud run holds no messaging creds of its own), park the task awaiting-decision, and continue other work (invariant 2). Fetch the answer next cycle from the same broker (step 1), never by reading the volume directly.

Prerequisite (must exist before vacation can escalate in production): your always-on agent exposes the broker pair on a bearer-auth'd endpoint — ask_owner(question) (in-container send + record a pending decision) and get_owner_answers(since) (read the chat log + match replies to pending ids). Usually a small addition to an existing MCP tool surface; the broker pair is the typical buildable gap. 5. Digest. Append a short cycle entry to the vacation log (PRs opened + links, decisions parked, budget used, what's queued next) — the 2-minute thing you skim from the road. Close early if the worklist is dry; an invented vigil to fill the schedule is not the job.

/vacation status

Read-only. Print: PRs opened this vacation (links + state), decisions awaiting your reply, work queued for the next cycle, and budget/window remaining. Writes nothing.

/vacation stop

Disarm: cancel the scheduled runs (via /schedule), post a final vacation summary (every PR opened + its state, every still-parked decision), and clear the vacation config. A single "stop vacation" text from you triggers this too (the kill switch).

Rules

• The floor never moves: branch + PR is the ceiling; merge/deploy/prod-push/public-post/secrets/.github//anything irreversible or outward-facing is refused, every cycle, no exceptions — you are unreachable for fast correction.
• Escalate over guess; one text, batched, rare: a consequential or ambiguous fork → a crisp brokered question + park + continue; never guess it, never block the shift on it, never spam (respect that you're on vacation — interrupt only for what genuinely needs you).
• Prove the channel before trusting it: start sends a test text and confirms delivery; a dead escalation line turns "ask when unsure" into "guess silently."
• Bounded + killable: per-cycle budget, a hard end date, and a one-text kill switch; runs stop themselves when the worklist is dry rather than manufacture work.
• Lane discipline — delegate, don't duplicate: the worklist + safety contract + verify go to /nightshift's engine; scheduling to /schedule; the text channel to your always-on agent's existing send/read; the refute pass to /code-review; PRs reuse the existing GitHub flow. vacation only adds the multi-day posture, the PR-opening step, and the escalation loop.
• Start conservative, widen with evidence: first vacation = short window, tight budget, escalate liberally, PRs small. Loosen only after a clean run — unattended multi-day autonomy is the highest-risk mode in the suite; earn the leash.

Sibling note: /nightshift = one night while you sleep, branch-only, never asks, morning brief. vacation = many days while you're away, opens PRs, asks via your agent when unsure, per-cycle digest. Same engine, different leash length set by reversibility + the ability to reach you.