- Hitting a usage / token cap and wanting to come back later without manually restarting
- Pausing for the day and wanting work to kick off overnight so HANDOFF restores the morning session
- Queuing a future GSD command (e.g.
/gsd:execute-phase 9 at 04:00) for off-peak quota use
No-token fallback. If you've hit your usage cap and the skill itself won't run (it needs tokens to parse args and call CronCreate — the very moment you don't have any), /exit the rate-limited session and invoke the shell wrapper from a plain terminal:
/exit # leave the rate-limited Claude session first
gsd-resume-at 17:41 # then schedule from your shell — no tokens consumed
# or with explicit duration / project:
gsd-resume-at +3h --project ~/code/myproject
# if `gsd-resume-at` isn't on PATH:
$CLAUDE_PLUGIN_ROOT/bin/gsd-resume-at +3h
# or fully absolute:
~/.claude/plugins/cache/gsd-plugin/gsd/<version>/bin/gsd-resume-at +3h
Pure shell — uses nohup sleep to schedule an OS-level timer, no Claude tokens consumed. macOS only for v1; the script will tell you if you're on another platform. Does NOT survive a reboot — for durable cross-reboot scheduling, use this skill (/gsd:resume-at) when tokens are available.
The plugin's Stop hook will surface this same hint automatically when it detects a rate-limit message in the session transcript.
This skill is a thin wrapper. The plugin already covers the resume itself (HANDOFF.json + /gsd:resume-work). What was missing was a way to ask Claude to come back at time T. This skill provides the scheduling on-ramp; Claude Code's built-in /schedule (or CronCreate primitive) does the durable cron storage.
Parse the time argument. The first positional argument is the target time. Accept three forms:
HH:MM — today at that local clock time. If the time has already passed today, schedule for tomorrow at the same time.
- ISO 8601 (e.g.
2026-04-28T08:00, 2026-04-28T08:00:00-04:00) — absolute timestamp. Use as-is.
+<duration> — relative offset from now. Accept +30m, +2h, +90m, +1d. Compute absolute target as now + duration.
If no argument is provided, ask the user via AskUserQuestion: "When should I resume? (e.g. 09:00, +2h, or 2026-04-28T08:00)". If parsing fails, surface the input and the supported forms; do not guess.
Resolve the command to schedule. Default is /gsd:resume-work (the plugin's standard resumption entry point — restores HANDOFF.json + STATE.md and routes to next action). If the user passed --cmd "<command>", use that command instead. Useful overrides:
--cmd "/gsd:next" — resume by jumping to the next workflow step (skips the status-print phase of resume-work)
--cmd "/gsd:execute-phase 9" — resume directly into a specific phase
--cmd "/gsd:quick <task description>" — schedule a quick task for later
Schedule via Claude Code's scheduling primitive. Use the Skill tool to invoke /schedule if the host CLI exposes it; otherwise fall back to CronCreate directly. Pass:
prompt: the resolved command (default /gsd:resume-work)
time: the absolute timestamp computed in step 1 (ISO 8601, with the local timezone)
- working directory: the current GSD project root, so the new session opens with HANDOFF.json visible
When /schedule/CronCreate isn't available in the current Claude Code build, surface that explicitly — don't silently no-op. Tell the user the plugin's resume-at skill needs the host's scheduling support, and link them to /schedule documentation.
Confirm what was scheduled. Print:
- Absolute time (local + UTC)
- The exact command that will fire
- The project directory the future session will open in
- A reminder that
HANDOFF.json is checkpointed every ≤60s during active work, so the resume reflects state from at most ~60s before this scheduling call (or from the most recent /compact if the session is currently idle)
Optional safety nudge. If the user did not pass --cmd and the current session has uncommitted dirty state (a non-empty git status -s), warn that a future /gsd:resume-work will pick up whatever HANDOFF reflects at scheduling time — they may want to /gsd:pause-work explicitly first to capture intent before scheduling.
✓ Resume scheduled
When: 2026-04-27 22:00 PDT (2026-04-28 05:00 UTC)
Command: /gsd:resume-work
Project: /Users/you/your-project
HANDOFF: written 47s ago (auto-postool)
If a /clear boundary makes sense (long session, scheduling at the end of an active day), suggest /clear per references/continuation-format.md. Otherwise, just confirm and stop — the user is presumably about to step away.
Source: davepoon/buildwithclaude → plugins/gsd/skills/resume-at/SKILL.md
1---
2name: gsdresume-at
3description: "Schedule a future resume of work - e.g. '/gsd:resume-at 09:00', '/gsd:resume-at +2h', or '/gsd:resume-at 04:00 --cmd /gsd:execute-phase 9'"
4allowed-tools: "Skill AskUserQuestion Bash"
5category: business-and-finance
6source_repo: davepoon/buildwithclaude
7source_path: "plugins/gsd/skills/resume-at/SKILL.md"
8source_url: https://github.com/davepoon/buildwithclaude/blob/HEAD/plugins/gsd/skills/resume-at/SKILL.md
9metadata:
10 source: https://skillmd.com/skills/davepoon/gsdresume-at
11---
12
13
14<objective>
15Schedule a future Claude Code session that automatically resumes the current GSD project at the requested time. Useful when:
16
17- Hitting a usage / token cap and wanting to **come back later** without manually restarting
18- Pausing for the day and wanting work to **kick off overnight** so HANDOFF restores the morning session
19- Queuing a future GSD command (e.g. `/gsd:execute-phase 9` at 04:00) for off-peak quota use
20
21> **No-token fallback.** If you've hit your usage cap and the skill itself won't run (it needs tokens to parse args and call CronCreate — the very moment you don't have any), `/exit` the rate-limited session and invoke the shell wrapper from a plain terminal:
22>
23> ```bash
24> /exit # leave the rate-limited Claude session first
25> gsd-resume-at 17:41 # then schedule from your shell — no tokens consumed
26> # or with explicit duration / project:
27> gsd-resume-at +3h --project ~/code/myproject
28> # if `gsd-resume-at` isn't on PATH:
29> $CLAUDE_PLUGIN_ROOT/bin/gsd-resume-at +3h
30> # or fully absolute:
31> ~/.claude/plugins/cache/gsd-plugin/gsd/<version>/bin/gsd-resume-at +3h
32> ```
33>
34> Pure shell — uses `nohup sleep` to schedule an OS-level timer, no Claude tokens consumed. macOS only for v1; the script will tell you if you're on another platform. Does NOT survive a reboot — for durable cross-reboot scheduling, use this skill (`/gsd:resume-at`) when tokens are available.
35>
36> The plugin's `Stop` hook will surface this same hint automatically when it detects a rate-limit message in the session transcript.
37
38This skill is a thin wrapper. The plugin already covers the *resume itself* (HANDOFF.json + `/gsd:resume-work`). What was missing was a way to ask Claude to come back at time T. This skill provides the scheduling on-ramp; Claude Code's built-in `/schedule` (or CronCreate primitive) does the durable cron storage.
39</objective>
40
41<process>
42
431. **Parse the time argument.** The first positional argument is the target time. Accept three forms:
44 - `HH:MM` — today at that local clock time. If the time has already passed today, schedule for tomorrow at the same time.
45 - ISO 8601 (e.g. `2026-04-28T08:00`, `2026-04-28T08:00:00-04:00`) — absolute timestamp. Use as-is.
46 - `+<duration>` — relative offset from now. Accept `+30m`, `+2h`, `+90m`, `+1d`. Compute absolute target as `now + duration`.
47
48 If no argument is provided, ask the user via AskUserQuestion: "When should I resume? (e.g. `09:00`, `+2h`, or `2026-04-28T08:00`)". If parsing fails, surface the input and the supported forms; do not guess.
49
502. **Resolve the command to schedule.** Default is `/gsd:resume-work` (the plugin's standard resumption entry point — restores HANDOFF.json + STATE.md and routes to next action). If the user passed `--cmd "<command>"`, use that command instead. Useful overrides:
51 - `--cmd "/gsd:next"` — resume by jumping to the next workflow step (skips the status-print phase of resume-work)
52 - `--cmd "/gsd:execute-phase 9"` — resume directly into a specific phase
53 - `--cmd "/gsd:quick <task description>"` — schedule a quick task for later
54
553. **Schedule via Claude Code's scheduling primitive.** Use the `Skill` tool to invoke `/schedule` if the host CLI exposes it; otherwise fall back to `CronCreate` directly. Pass:
56 - `prompt`: the resolved command (default `/gsd:resume-work`)
57 - `time`: the absolute timestamp computed in step 1 (ISO 8601, with the local timezone)
58 - working directory: the current GSD project root, so the new session opens with HANDOFF.json visible
59
60 When `/schedule`/CronCreate isn't available in the current Claude Code build, surface that explicitly — don't silently no-op. Tell the user the plugin's `resume-at` skill needs the host's scheduling support, and link them to `/schedule` documentation.
61
624. **Confirm what was scheduled.** Print:
63 - Absolute time (local + UTC)
64 - The exact command that will fire
65 - The project directory the future session will open in
66 - A reminder that `HANDOFF.json` is checkpointed every ≤60s during active work, so the resume reflects state from at most ~60s before this scheduling call (or from the most recent `/compact` if the session is currently idle)
67
685. **Optional safety nudge.** If the user did not pass `--cmd` and the current session has uncommitted dirty state (a non-empty `git status -s`), warn that a future `/gsd:resume-work` will pick up *whatever HANDOFF reflects at scheduling time* — they may want to `/gsd:pause-work` explicitly first to capture intent before scheduling.
69
70</process>
71
72<output_format>
73After scheduling, emit a confirmation block:
74
75```
76✓ Resume scheduled
77 When: 2026-04-27 22:00 PDT (2026-04-28 05:00 UTC)
78 Command: /gsd:resume-work
79 Project: /Users/you/your-project
80 HANDOFF: written 47s ago (auto-postool)
81```
82
83If a `/clear` boundary makes sense (long session, scheduling at the end of an active day), suggest `/clear` per `references/continuation-format.md`. Otherwise, just confirm and stop — the user is presumably about to step away.
84</output_format>
85
86<rules>
87- This skill **never** advances or deletes HANDOFF.json. The scheduled session does that via `/gsd:resume-work`.
88- The skill **does not poll, sleep, or block** — it returns immediately after scheduling.
89- If the user passes `--cmd` with a non-`/gsd:` command (e.g. `/help`), pass it through anyway. Resume-at schedules; it does not gatekeep what runs.
90- Times in the past (after parsing) are an error — surface the parsed timestamp and ask for a new value. Do not silently round up to "now + 1m".
91- When scheduling uses CronCreate directly, prefer **one-shot** scheduling (single fire), not recurring. Recurring resume is a separate use case (`/loop` covers that).
92</rules>
93
94<notes>
95- Why a wrapper, not a reimplementation: Claude Code's `/schedule` and `CronCreate` already handle persistence-across-restarts, timezone math, and authorization correctly. Building our own would duplicate complex code and drift over time. Resume-at exists purely to translate GSD-flavored input (`+2h`, default `/gsd:resume-work`) into the form `/schedule` expects.
96- Why default `/gsd:resume-work` and not `/gsd:next`: `resume-work` prints status and routes — useful when you might forget where you were. `next` jumps straight to action. Default is the safer first-impression choice; users with a clear destination override via `--cmd`.
97- The complement skill is `/gsd:resume-work` (deletes HANDOFF after restoring) and `/gsd:pause-work` (writes HANDOFF on demand). `resume-at` schedules; resume-work restores; pause-work captures.
98</notes>
99
100---
101
102**Source:** [`davepoon/buildwithclaude`](https://github.com/davepoon/buildwithclaude) → `plugins/gsd/skills/resume-at/SKILL.md`