Skip to content
Skills Library
AI & agents · Automation

project-wake

/project-wake

Manual sweep of a SpecWithCode project after an update, restart or outage: list every thread, continue only work the restart cut off and the app did not continue, never touch work a person stopped, hand off one thread at a time only through existing handoff tools, and ask owners of finished-but-unclosed work to verify, review and close it. Use only when the user invokes $project-wake or /project-wake, or explicitly asks to run project wake in a project coordinator. Not for schedules, routine status questions, or outside SpecWithCode (it needs the studio-code MCP tools).

Repository
vskill ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Manual sweep of a SpecWithCode project after an update, restart or outage: list every thread, continue only work the restart cut off and the app did not continue, never touch work a person stopped, hand off one thread at a time only through existing handoff tools, and ask owners of finished-but-unclosed work to verify, review and close it. Use only when the user invokes $project-wake or /project-wake, or explicitly asks to run project wake in a project coordinator. Not for schedules, routine status questions, or outside SpecWithCode (it needs the studio-code MCP tools).

Original author description

Manual sweep of a SpecWithCode project after an update, restart or outage: list every thread, continue only work the restart cut off and the app did not continue, never touch work a person stopped, hand off one thread at a time only through existing handoff tools, and ask owners of finished-but-unclosed work to verify, review and close it. Use only when the user invokes $project-wake or /project-wake, or explicitly asks to run project wake in a project coordinator. Not for schedules, routine status questions, or outside SpecWithCode (it needs the studio-code MCP tools).

How it works

  1. 1. Inventory
  2. 2. Classify each thread
  3. Rules for every send
  4. 3. Continue cut-off work
  5. 4. Out of quota, or the machine is gone
  6. 5. Finished but not closed
  7. 6. Report
Original SKILL.md headings · 67 lines, 1,103 words
SKILL.md preview
---
name: project-wake
description: "Manual sweep of a SpecWithCode project after an update, restart or outage: list every thread, continue only work the restart cut off and the app did not continue, never touch work a person stopped, hand off one thread at a time only through existing handoff tools, and ask owners of finished-but-unclosed work to verify, review and close it. Use only when the user invokes $project-wake or /project-wake, or explicitly asks to run project wake in a project coordinator. Not for schedules, routine status questions, or outside SpecWithCode (it needs the studio-code MCP tools)."
metadata:
  version: "1.0.5"
  category: productivity
  tags: specwithcode, coordinator, restart, update, resume, handoff, threads, orchestration
---

# project-wake

One manual sweep of the current project. The user invoking `$project-wake` (or `/project-wake`) authorizes continuing interrupted work inside the rules below and nothing else. The coordinator routes, it does not implement: every action is one message to the thread that already owns the work.

## 1. Inventory

- `studio_thread_list` with no `machine` (federated), `includeArchived: false`, `limit: 100`; repeat with `cursor = nextCursor` until it is null. Keep `partial` and every unavailable or unauthorized member: their threads are **unknown**, never dead, and are never resumed or duplicated from here, except through step 4's handoff tools when `studio_handoff_ready_list` lists them.
- Skip the calling thread, and threads whose `settled` is true unless the user named them.
- Remember each thread's machine. Pass that `machine` on every `studio_thread_read` and `studio_thread_send` for a thread that is not on this machine. `studio_queue_list`, `studio_queue_resume`, `studio_thread_configuration` and `studio_pending_request_list` only see this machine: for a remote thread whose state depends on them, classify it **unclear**.
- Call `studio_machine_list` once for which machines are ready. Provider quota is not listed anywhere: treat a provider as out of quota only when the thread's own failure text or a reset time says so.

## 2. Classify each thread

Read the latest run with `studio_thread_read` (`view: "activity"`, `runLimit: 1`), paging with `afterPosition = nextPosition` until `nextPosition` is null. Use run status and the interrupt, failure and approval items, not the title.

| State | Evidence | Action |
|---|---|---|
| Running or queued | status running/starting/queued, or `studio_queue_list` shows undelivered messages that are not held | Leave alone. Never add a second executor or watcher. |
| Already continued by the app | a newer run or a "Continue where you left off" / update-continuation message after the interrupt | Leave alone. |
| Cut off by update or restart | interrupted with cause `service_update` or restart; "Closed to install the SpecWithCode update."; failed with "The provider event stream closed unexpectedly" only when the same thread's activity also shows an update or restart notice; or `cancelled` with no interrupt request and an update or restart notice in the same thread | Step 3, after the wait below. |
| Never started | "The provider did not start this turn within 2 minutes" or "Run interrupted before provider start" | Step 3, once. The app never retries these. |
| Stopped by a person | an interrupt request from the user, Stop, or `cancelled` with an interrupt request | Leave it. A person's Stop is final; list it. A `cancelled` run with neither an interrupt request nor an update or restart notice is **unclear**. |
| Waiting on a person | a pending question or approval in the activity, or a `studio_pending_request_list` entry | Leave it; list what is asked. |
| Usage limit | quota or rate-limit failure text, a reset time | Step 4. |
| Real failure | provider, tool or code error unrelated to an update | Do not retry. Report the error text and the owner. |
| Finished, not closed | completed run that says the work is done, with an increment that still has open tasks, unverified ACs or an open PR | Step 5. |
| Finished and closed | completed, increment closed or no remaining work | Nothing. Never wake it to poll. |

When the evidence does not settle it, mark the thread **unclear** and report it; do not act.

## Rules for every send

These apply to every `studio_thread_send` in steps 3 and 5.

- A send releases the thread's held queue. Check `studio_queue_list` first: if the queue is held and the hold does not follow an update or restart interrupt in the activity, treat it as a person's hold (a hold after a provider failure counts as a person's too), so do not send. Never call `studio_queue_resume` on a person's hold.
- For a thread on another machine the queue is not visible: send only when its activity shows no Stop by a person after the interrupt; otherwise mark it **unclear**.
- Read the result: report any `releasedHeldMessages`, and if it has `queueHeld: true`, report the message as not delivered, with its `notice`.

## 3. Continue cut-off work

- The app continues update-cut runs under 24 hours old on its own. Act on a cut-off run only when the interrupt is at least 15 minutes old and no newer run or continuation message exists. Re-read the thread immediately before sending; if anything changed, leave it.
- Only on the thread's own provider and model, with no model or permission change.
- Send one message to the same thread with `studio_thread_send`, `mode: "auto"`, `clientRequestId: "project-wake:<threadId>:<latestRunId>"` so a second sweep cannot double-send: "SpecWithCode restarted and cut this turn off. Re-read your last messages and the repository state, then continue the same task where it stopped. If it is already finished, verify that and report instead of redoing it."
- Never use `studio_threads_continue_all`: it also continues runs a person stopped.

## 4. Out of quota, or the machine is gone

- Never switch to an API-billed, pay-per-token or other paid provider, never raise a thread's permission mode, and never pass `modelSelection` to any tool.
- If the user's configured fallback order covers this provider, the app applies it; report the reset time and leave the thread.
- If the owning machine is offline: read `studio_handoff_ready_list` and call `studio_thread_continue_here` only for a thread it marks continuable, without `modelSelection`. That is the only way to continue a thread from an offline machine.
- `studio_thread_migrate` is the alternative for a thread on this machine only (it refuses threads elsewhere): to move it to a ready machine, pass exactly one `threadIds` entry; omitting `threadIds` moves every running handoff-mode thread. A refusal is final; report it.
- Otherwise list the thread as blocked with the provider, reset time or machine.

## 5. Finished but not closed

Send the owning thread one message, `clientRequestId: "project-wake-close:<threadId>:<latestRunId>"`, asking it to close its own work: record finished tasks, run `specweave verify <id>`, get a review in a fresh context, then `specweave complete <id>`, and report any gate that stops it. Do not verify, review or close it from the coordinator, and never count source, a merged PR or green CI as installed or manual acceptance.

## 6. Report

End with one table, then one line of totals:

| Thread | Found | Action | Needs you |
|---|---|---|---|

Link each thread with the `threadLink` the tools return. "Needs you" is only what a person must do: answer a question, sign in, approve a grant, wait for a reset, or decide on a real failure.
Files in this package (3)
  • SKILL.md 7 KB
  • agents/openai.yaml 1 KB
  • evals/evals.json 8 KB

Versions

The database has no other skills named project-wake.

Database snapshot: 13.11.2026 · package version f8b154b5c17e (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100ormeggio
    Bring back the sessions that stalled while the user was away: find the ones interrupted by a usage limit (429), an expired login (401), a shutdown or restart, a tool left halfway or background agents reported stopped, resume them a dozen at a time after a memory check, and…
  • 100cq-start
    Start or wake this session's cq queue watcher - clear its sleep flag, reload its handoff, check its queue scope and arm the watcher. Use when the user says start cq, join the queue, wake up, or when a coordinator's wake message asks this session to rejoin. A coordinator can give…
  • 100wake-sessions
    Schedule a wake-up of other existing Claude Code or Codex sessions after a session or quota limit resets. Discover their exact cmux surfaces, Herdr agents or other supported live addresses, plan delivery now, then use delayed-work:until to wake this caller and nudge the same…
  • 100thread-ops
    Use when you need to interact with other threads or manage thread lifecycle. Covers dispatching work to subagents / forks / existing sessions via a single primitive, inspecting session state by key, scheduling a delayed self-wake (via the manage-cron set-at --direct-wake job),…
  • 98yobiru-wake
    Configure whether and how other machines' Yobiru (tailmsg) messages wake this machine's agents - receiver-side wake policy per sender, quiet hours, rate limits, and per-agent wake adapters (a local program, a Grok Bot routine webhook, or the optional Codex bridge for macOS…
  • 87switchroom-runtime
    Use ONLY when the user is asking the AGENT ITSELF about its own runtime state in a specific runtime-context — i.e. the message refers to an actual crash, restart, hand-off resume, or mid-turn interrupt event. Required disambiguator: the prompt must reference one of these…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.