Long Task Continuation

Long Task Continuation

Overview

Use this skill to keep long tasks checkpointed, resumable, drift-aware, and evidence-gated.

This is a protocol skill. It does not execute plans, dispatch subagents, run tests, or grant completion authority.

Authority Boundary

Current owner:

• Method Pack protocol discipline

Not owned here:

• plan execution
• subagent dispatch
• host daemon / watchdog / automatic retry
• authoritative GateDecision
• evidence sufficiency final judgment
• completion authority

When To Use

Use this skill when any of these are true:

• the task has multiple phases or more than one meaningful work slice
• the task may be interrupted, compacted, resumed, or handed off
• the task uses subagents
• the user explicitly asks for long-task continuity, resume safety, or avoiding drift
• the task changes architecture, contracts, shared workflows, or verification gates

For short direct answers or one-command checks, do not force this protocol.

Required Artifacts

Maintain artifacts under docs/aegis/work/YYYY-MM-DD-<slug>/:

| Artifact | File | When |

|----------|------|------|

| TaskIntentDraft | 10-intent.md and optional task-intent-draft.json | Start protocol |

| BaselineReadSetHint | 10-intent.md (inline) | Start protocol |

| BaselineUsageDraft | 10-intent.md (inline) and optional baseline-usage-draft.json | Start protocol and when baseline usage changes |

| ImpactStatementDraft | 10-intent.md (inline) | Start protocol |

| TodoCheckpointDraft | 20-checkpoint.md and optional todo-checkpoint-draft.json | Each checkpoint |

| ResumeStateHint | 20-checkpoint.md (inline) | Each pause/handoff |

| DriftCheckDraft | 20-checkpoint.md (inline) and optional drift-check-draft.json | Per-slice protocol |

| EvidenceBundleDraft | 90-evidence.md and optional evidence-bundle-draft.json | Per-slice protocol |

| Reflection | 99-reflection.md | Completion candidate |

For medium+ complexity tasks only. Low-complexity tasks skip work/.

Execution Readiness View may be included inline in 10-intent.md or the

active checkpoint when the workstream is medium/high, subagent-driven,

handoff-prone, long-running, architecture / contract sensitive, or

compatibility / retirement sensitive. It is a human-readable rendering of

existing drafts and the parent plan, not a new JSON artifact type and not

completion authority.

Planless Slice Lane:

• Use this lane when a parent plan or parent spec already owns the long-task

workstream and the current micro-slice only executes or refines one bounded

parent task.

• Record a compact Slice Card instead of creating another durable plan/spec:

  Slice Card:
  - Goal:
  - Parent plan/spec:
  - Files:
  - Boundary:
  - Verification:
  - Stop:

• Slice Card Goal anchors slice-level completeness only.
• It does not by itself grant whole-task completion.
• Final completion still requires verification-before-completion Goal Closure

against the parent plan/spec and any active goal frame, rendered through the

unified Aegis impact/safety receipt unless audit detail is requested.

• Do not create new plan/spec files for micro-slices that stay inside the

parent plan, existing compatibility boundary, and known verification path.

• Update the existing checkpoint, evidence, and drift records when persistent

state is needed.

• Escalate out of this lane only when a new owner, contract, schema, public API,

architecture boundary, migration, persistence, security/permission,

distribution/release surface, or unclear verification boundary appears.

When durable architecture decisions are in scope, these work records are the

preferred ADR Auto Backfill source. Preserve ADR signals, source refs,

alternatives, compatibility boundaries, drift checks, retirement notes, and

baseline-sync questions in the work record instead of relying on memory at

completion time.

These are draft / hint / projection inputs. They are not authoritative runtime records.

Workspace Helper Protocol

When configured Aegis workspace support or installed Aegis workspace support is

available, use it for the target project workspace and lifecycle records:

• Initialize before writing work records:

   python <aegis-workspace-helper> init --root <target-project-root>

• For a new medium+ task process trail, prefer helper-backed lifecycle

creation over hand-created files:

   python <aegis-workspace-helper> new-work --root <target-project-root> --date YYYY-MM-DD --slug <slug> --title "<title>" --requested-outcome "<outcome>" --scope "<scope>" --change-kind <kind>

• After each slice, update checkpoint, evidence, and drift through the helper:

   python <aegis-workspace-helper> add-checkpoint --root <target-project-root> --work YYYY-MM-DD-<slug> ...
   python <aegis-workspace-helper> add-baseline-usage --root <target-project-root> --work YYYY-MM-DD-<slug> ...
   python <aegis-workspace-helper> add-evidence --root <target-project-root> --work YYYY-MM-DD-<slug> ...
   python <aegis-workspace-helper> add-drift-check --root <target-project-root> --work YYYY-MM-DD-<slug> ...

• Before pause, handoff, or completion candidate, assemble a structural proof

bundle and check the workspace:

   python <aegis-workspace-helper> bundle --root <target-project-root> --work YYYY-MM-DD-<slug>
   python <aegis-workspace-helper> check --root <target-project-root>

These helper checks validate workspace structure, index coverage, and JSON

sidecar shape only. They do not determine evidence sufficiency, do not produce

authoritative GateDecision, and do not grant completion authority.

Start Protocol

Before long-task execution:

• State the requested outcome, scope, non-goals, and risk hints.
• If goal framing exists, restate goal, success evidence, stop condition, and

non-goals. Stop condition must allow done, blocked, needs-verification, and

scope-exceeded outcomes.

• Identify baseline refs that must be read before changing files.
• Record baseline usage state:
• required baseline refs
• optionally delivered context refs when the host can project them
• acknowledged before plan refs
• cited in plan refs
• missing refs
• Create or update the todo map.
• If the parent plan or workstream needs an execution handoff, render or link

an Execution Readiness View:

• intent lock
• scope fence
• baseline lock
• owner / contract constraints
• compatibility boundary
• retirement boundary
• task batches
• test obligations
• review gates
• drift / rewind rules
• evidence required before completion
• advisory boundary
• Create the first checkpoint:
• current todo
• active slice
• completed todos
• evidence refs
• blocked-on items
• next step
• If baseline refs are missing, pause in needs-baseline-readback.
• If the workspace helper is available, use aegis-workspace.py new-work to

create/index the first docs/aegis/work/ files and run `check --root

<target-project-root>` before continuing.

Per-Slice Protocol

Before each work slice, restate:

• current goal
• current todo
• intended edits
• explicit non-edits
• verification command or manual check
• Execution Readiness View alignment when one exists

For micro-slices under an existing parent plan, use the Planless Slice Lane and

state the Slice Card instead of opening a new planning/specification artifact.

After each work slice, update:

• completed todos
• evidence refs
• baseline usage if newly required refs were acknowledged, cited, or found missing
• blockers
• next step
• drift check
• helper-backed JSON sidecars through aegis-workspace.py add-checkpoint,

aegis-workspace.py add-baseline-usage, aegis-workspace.py add-evidence, and aegis-workspace.py add-drift-check

when available

When patch-shape/ripple triage, an H-class finding, or a bounded compatibility

mitigation fired, a locally green result does not clear that direction. Reuse

checkpoint prose and evidence refs to retain PatchShape, CanonicalOwner,

UpwardDrillSignal, decision, latest outcome, and one bounded evidence ref;

do not copy raw logs or full diffs.

If no fresh evidence exists, the state is needs-verification or partial.

Resume Protocol

When resuming:

• Read latest checkpoint.
• Read latest resume hint if present.
• Re-read original task intent.
• Re-read required baseline refs.
• Passively re-read relevant active CONTEXT.md language for non-trivial work.
• Re-read the Execution Readiness View if present.
• Compare current worktree state with checkpoint claims.
• Compare the slice with the view's intent, scope, baseline, compatibility,

retirement, test, and review locks.

• If checkpoint, baseline, context, view, and worktree disagree, compose

establishing-project-context for semantic conflict; otherwise pause or

return to planning.

10. Before an unplanned repair, read retained invariant, owner seam, patch shape,

and causal topology and route comparison to systematic-debugging; a new

carrier name alone does not prove a new direction.

Never resume from memory alone.

Drift Check

Answer these after each slice:

• Does the current work still serve the original task intent?
• Does the current work still serve the goal and stop condition?
• Did the slice stay inside the compatibility boundary?
• Did any new owner, fallback, adapter, or branch appear?
• Is the retirement track still explicit?
• Did the evidence bundle grow enough to support the next claim?
• If an Execution Readiness View exists, does the active slice still match

its intent lock, scope fence, baseline lock, compatibility boundary,

retirement boundary, test obligations, and review gates?

Allowed decisions:

• continue
• pause-for-user
• needs-baseline-readback
• needs-verification
• blocked

Forbidden decisions:

• gate-passed
• completion-granted
• authoritatively-safe

Completion Candidate Protocol

Before saying work is complete:

• Use aegis:verification-before-completion.
• Confirm every todo has a status.
• Confirm blockers are resolved or externalized.
• Confirm evidence refs cover the acceptance criteria.
• Confirm drift check has no blocking state.
• Run `python <aegis-workspace-helper> bundle --root <target-project-root>

--work YYYY-MM-DD-<slug>` if the helper is available and a work record

exists.

• Run python <aegis-workspace-helper> check --root <target-project-root>

if the helper is available and the task wrote docs/aegis/ records.

• Treat the generated GateInputPack as future-runtime input only.
• If durable architecture decisions were in scope, pass the work record,

proof bundle, drift checks, evidence refs, and ADR signals into

aegis:verification-before-completion for ADR Backfill Check.

Method Pack output is verified evidence and advisory judgment only. It is not authoritative completion.

Minimal Reporting Shape

Use this shape for long-task updates:

• Aegis Visibility: why checkpoint, resume, drift, handoff, or parent-plan

discipline is shaping the next step

• TodoCheckpointDraft: current todo, completed todos, active slice, next step
• BaselineUsageDraft: required refs, acknowledged refs, cited refs, missing refs, decision
• Execution Readiness View: present | absent | refreshed | stale, and the

alignment signal when present

• Evidence: commands, files, logs, or manual checks
• DriftCheckDraft: scope, compatibility, retirement, decision
• Risk / Unknown: unresolved blockers or missing evidence
• Next: the next smallest safe action