Skip to content

Resume and Recover Work

An interrupted conversation is not a reason to start a new project. First identify the repository, branch or worktree, existing slug, artifact format and last known operation. Keep the files and failure output. A short excerpt can help diagnosis; redact credentials, private remote URLs, user-home paths and confidential code before sharing it publicly.

Use the existing feature or sprint entry and name the original work. Explicit feature spellings are /ca:feature, $ca-feature and /ca-feature; sprint follows the same host-specific pattern. A useful instruction is: “Resume the existing saved-search export work. Inspect current state and report what is safe to continue. Do not recreate the artifacts or discard unrelated edits.”

The lane must inspect durable state rather than infer progress from the previous chat. For typed work, the coordinator uses validated reads and current bindings. Browser inspection is useful to you, but opening an HTML file does not reconcile or approve anything.

Observed stateWhat it establishesNext boundary
Draft spec or draft-preview plan
Content exists and may be incomplete
Inspect missing requirements and current binding; continue independent authorized work
PENDING task
Implementation has not started
Inspect actual dependencies and advisory eligibility before selecting useful work
IN_PROGRESS after interruption
Work may have partly executed
Inspect changes and reconcile before redispatch
REVIEW
Implementation is ready for review
Inspect actual check results and relevant review needs; the label proves neither
BLOCKED
A recorded condition prevents selection
Resolve the named condition; do not clear state merely to retry
DONE
Implementation completion was recorded
Required checks may still be pending or failing; inspect their actual results
ACCEPTED
Independent acceptance evidence was recorded
Check its scope, current source and bindings before making that proof claim

Feature and sprint work may continue independent authorized tasks while another task is blocked. Bounded recovery can try a genuinely different strategy, but never clears a user stop, invents authority or promotes a task by changing a label. Respect an explicitly requested pause; routine batch reports do not require acknowledgment. If the same approach fails without new information, diagnose differently or retain the bounded blocker instead of retrying indefinitely.

Read the reason before retrying

These are explanations of task states and diagnostic codes, not live state from your repository.

AUTHORITY_UNVERIFIEDAn explicit attestation operation lacks current evidence.

Next safe action: Keep that proof claim unproved and inspect its applicable host-owned evidence boundary. Ordinary authorized work still follows actual permissions and checks; preserve receipts without relabelling or inventing them.

DRAFT_BINDINGThe requested operation requires a different specification binding.

Next safe action: Inspect the selected identity and the operation that failed. Use native plan-binding maintenance for ordinary authoring; an explicit attestation operation retains its separate evidence requirements. Advisory eligibility and draft status are not execution permission.

IN_PROGRESSAn interrupted task may have changed files without finishing its review.

Next safe action: Inspect those files and the recorded task state. Reconcile through the owning workflow before redispatch.

REVIEWImplementation was marked ready for review.

Next safe action: Inspect actual checks and applicable review requirements. The label establishes neither a passing test nor an independent review.

DONEImplementation completion was recorded.

Next safe action: Read actual check outcomes and report missing, failed or unrun verification separately. Continue authorized work while preserving real dependencies and user stops.

BLOCKEDA hard boundary or exhausted recovery strategy stopped this task.

Next safe action: Resolve its specific reason. Preserve the failed strategy and attempt record; continue only independent authorized work.

STALE_CURSORA contributing specification, plan or authority record changed after the read.

Next safe action: Read the current context again and reconsider the action. Never force the old cursor.

RECOVERY_REQUIREDA transaction needs inspection before its outcome is known.

Next safe action: Use the recorded operation ID and the recovery path. Do not replay the write with a new ID or remove its journal.

Progress labels, advisory scheduling and explicit attestation are distinct. Expanding these explanations never changes a task or grants permission.

CAPABILITY_MISSING, INVALID_INSTALLATION, PACKAGE_INTEGRITY, UNVERIFIED_PLATFORM and UNSUPPORTED_PLATFORM are capability or package failures. Use doctor and the installed host’s capability report to identify the exact package and platform. Reinstall a qualified package only when that diagnosis calls for it. Do not fetch an arbitrary binary, use a project-supplied engine, or set a PATH/environment override to bypass the installation-owned manifest.

Binding, explicit attestation and concurrent changes

Section titled “Binding, explicit attestation and concurrent changes”

Inspect the operation that returned the diagnostic. For ordinary authoring, check the selected specification identity and use the native plan-binding workflow when its binding needs updating. Draft status and advisory eligibility do not grant or deny the user’s existing authorization. Structural failures, concurrent-write conflicts and actual missing requirements still need repair.

For an explicit attestation operation, DRAFT_BINDING or AUTHORITY_UNVERIFIED can indicate missing current proof. That claim remains unproved until its applicable evidence boundary succeeds; do not fabricate a receipt. The host authority matrix distinguishes an unavailable adapter from missing evidence. That limitation does not impose an approval-receipt gate on ordinary authorized implementation.

After an upgrade, receipt format codearbiter.receipt/0.1.0 remains inspection-only in the current source contract. An explicit attestation claim requires a current codearbiter.receipt/0.2.0 receipt from its applicable policy-owned boundary. These are receipt formats, not plugin versions. Preserve old evidence; do not relabel a receipt or replay a pasted decision as a newly captured event. Actual user instructions still govern ordinary authorized work.

REVISION_CONFLICT or STALE_CURSOR means a read no longer describes the current definition or a contributing record. Reread, reconsider the intended change, and obtain fresh contextual reads. Never force the previous write through.

RECOVERY_REQUIRED or COMMIT_OUTCOME_UNKNOWN requires inspection of the recorded transaction using its operation ID. Preserve that ID and the original failure. Ask the owning workflow to inspect recovery status before retrying. Starting another write with a new operation ID can make an uncertain outcome worse. LOCK_BUSY is not permission to delete lock files.

For an interrupted host-owned reconciliation, let the adapter recover the exact stored operation and receipt. A lost mutation response can require replay of the same durable operation, not a new approval event. Cancellation must not clear an in-flight mutation. Verify the committed outcome and inspect advisory eligibility before continuing; an observed prompt is not proof the mutation committed.

UNSUPPORTED_VERSION and UNSUPPORTED_RENDERER require a reviewed compatibility path. They do not authorize reinterpretation, raw JSON repair or replacement of an HTML pair with Markdown. Existing legacy Markdown pairs continue on their original path; explicit pair migration is a separate operation with drafts, retained legacy bytes and guarded rollback.

Ask for the original artifact IDs, format, current revision/binding, any reconciled changes, and the next eligible task or remaining stop. Confirm required tests and reviews refer to the actual current change. A successful retry alone does not prove earlier records were preserved.

If a required capability, actual permission or transaction outcome remains unknown, stop the dependent action and preserve its records; continue unaffected authorized work where possible. Restore lost governing files from known version-control or transaction history through the appropriate recovery path rather than fabricating evidence. Do not manually edit HTML, receipts, protected task boards or append-only logs.

The format and troubleshooting guides cover the adjacent boundaries. The repository’s migration and recovery contract is the detailed current-source protocol, not proof that every installed release supports it.