scrumrun 2.5.1 → 2.6.0

package/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes follow Semantic Versioning.
 
 ## Unreleased
 
+## 2.6.0 - 2026-08-21
+
+### Added
+
+- **Project Briefing** — `state.md` is now a structured briefing (`## Now`, `## Recent`, `## Open Decisions`, `## Active Memory`, `## Next Up`, `## Where to look`) instead of a flat active-work list. It is the progressive-disclosure entry point: agents read the briefing first and only go deeper when it lacks what they need. Recent completions surface their technical summaries so the next agent knows what was just done without reading full ledgers. `buildContextPackage` now includes a `briefing` field.
+- **Acceptance Criteria** — every approved Task body gains an `## Acceptance Criteria` section so "done" is defined before execution. Conformance emits a non-blocking `ACCEPTANCE_CRITERIA_MISSING` warning for active Tasks that lack it.
+- **Technical Summary** — `sc plan run --complete --summary "…"` stores a `## Technical Summary` section on the Run, surfaced later in the briefing and context package so completed work informs future intake. `appendTechnicalSummary`/`extractTechnicalSummary` are exported for library consumers.
+- **`--type` override** — `sc plan intake "…" --type fix|task|feature|docs|discovery` lets the agent assert the classification explicitly, overriding keyword inference with validation and a stable reason.
+- **`--preview`** — `sc plan intake "…" --preview "technical summary"` renders a cyan Preview field in the pretty terminal layout (mirroring the landing page), binds it into the approval token, and stores it as `## Preview` on the Task.
+- **Auto-sequencing** — `sc plan task --next` surfaces the oldest backlog Task; `sc plan task --start [TASK-NNN]` promotes it to `running`, creates a Run, re-evaluates policy, and records the agent identity. The briefing's `## Next Up` lists the queue.
+- **Agent identity and assignment** — `SCRUMRUN_AGENT` env var (or `Agent Identity` in `config.md`) sets the agent identity recorded as the `assignee` on approved/started Tasks and as the `actor` on Run transitions. The briefing shows the assignee next to active work for team visibility.
+
+### Changed
+
+- `state.md` projection schema bumped 1 → 2 (regenerated automatically; the previous format is superseded, never migrated by hand).
+- `update` now regenerates the disposable briefing after installing integrations, so upgrading from 2.5.x has no friction with the previous `state.md` format. All other changes are additive (new sections and fields) and do not require migration.
+
+### Validation
+
+- Test suite grew from 192 to 213 passing.
+
 ## 2.5.1 - 2026-07-23
 
 ### Fixed

package/CORE.md

@@ -108,10 +108,12 @@ Normal read path:
 
 1. `AGENTS.md`;
 2. `.scrumrun/guardrails.md`;
-3. `.scrumrun/state.md`;
+3. `.scrumrun/state.md` — the **briefing**: a bounded summary of active work, recent completions with their technical summaries, open decisions, active memory, the backlog queue, and pointers;
 4. only the canonical ids and evidence relevant to current work;
 5. `.scrumrun/core.md` when method details or exceptional transitions are needed.
 
+The briefing is a progressive-disclosure index, not full context. Read it first and follow its pointers to specific artifacts (`## Where to look`, `sc knowledge study "<topic>"`). Go deeper — a Task body, a Run ledger, a Decision — only when the briefing lacks what you need. Never treat the briefing as a substitute for the canonical artifact it points to.
+
 Lean mode is this bounded read policy; it is not permission to omit canonical truth.
 
 `guardrails.md` is the sole canonical project-policy file. `golden-rules.md` is a v1 migration source/compatibility pointer, not a competing authority. `config.md` stores interaction preferences and cannot weaken guardrails.
@@ -154,6 +156,8 @@ Intake must:
 
 Policy evaluation is structured per active `GR-NNN`: `passed`, `blocked`, or `deferred`. A block must cite the exact Guardrail id and reason code. Deferred checks must be visible in the plan and re-evaluated at their named execution boundary; they are never silently counted as passed. Invalid/duplicate Guardrails or configuration that weakens approval block conformance and intake.
 
+The agent may assert the classification explicitly with `sc plan intake "…" --type fix|task|feature|docs|discovery`, overriding keyword inference (validated, with a stable reason). It may also attach a short technical explanation with `--preview "…"`, rendered in the pretty terminal layout, bound into the approval token, and stored as `## Preview` on the Task.
+
 Before approval, do not create canonical files, update status, edit application code, or retain request content outside ignored disposable context cache. The approval token binds both canonical context and the workspace fingerprint; drift in either requires a new intake. Ambiguous acknowledgement is not approval.
 
 ## Execution lifecycle
@@ -177,11 +181,13 @@ Rules:
 - the Run ledger is operational history; Task synchronizes current status without copying the Run event;
 - validation, learning, completion, failure, block, and resume require a reason or evidence;
 - validation must match the risk and acceptance criteria;
+- each Task declares its `## Acceptance Criteria` before execution; check them off as evidence, never mark done on vibes;
 - configured reviews run before completion;
 - every deferred policy result is persisted as a Run Guardrail obligation;
 - before changing application/source files, issue a short-lived path-scoped mutation permit and record the verified before/after hashes in the Run;
 - unrecorded workspace drift, policy drift, out-of-scope paths, unsafe symlinks, new secret-like content, or unresolved obligations block validation/completion;
 - learning proposes memory candidates after validation and never auto-confirms AI inference;
+- record a `## Technical Summary` at completion with `sc plan run --complete --summary "…"` so the next agent inherits what was actually done;
 - complete a Sprint only when all its included Tasks meet the Sprint exit gate;
 - do not mark work complete merely because time or token budget ended.
 
@@ -189,6 +195,14 @@ Canonical mutations are schema-validated, lossless, and atomic. Preserve unknown
 
 Task/Run pair mutations use an ignored durable journal under `.scrumrun/.backup/transactions/`. A captured failure rolls back immediately; an interrupted `prepared` transaction is rolled back before the next approved mutation, while an interrupted `committed` transaction is verified and finalized. Audit only reports `TRANSACTION_PENDING`. Recovery writes occur only when the approved operation is retried or `doctor --recover` is explicitly invoked, and recovery refuses to overwrite bytes that match neither side of the journal.
 
+### Backlog and sequencing
+
+Backlog is the queue of Tasks with `status: backlog`, ordered oldest-first by id. When a Run completes, the briefing's `## Next Up` names the next backlog Task. `sc plan task --next` shows it; `sc plan task --start [TASK-NNN]` promotes it to `running`, creates its first Run, re-evaluates policy, and records the agent identity. Starting is itself the explicit approval (I-01): no work executes silently, and the owner can always say "not now".
+
+### Agent identity and assignment
+
+Each agent declares an identity via the `SCRUMRUN_AGENT` environment variable or the `Agent Identity:` field in `config.md` (single-agent default). The identity is recorded as the `assignee` on approved/started Tasks and as the `actor` on Run events. In `--shared` teams, every agent sets its own `SCRUMRUN_AGENT` and reads the briefing's `## Now` to see who owns each active Task before picking up work; file locks and the transaction journal prevent corruption on concurrent edits.
+
 ## Semantic memory
 
 ### Knowledge
@@ -252,11 +266,11 @@ Legacy sprint plan entries normally become Tasks. History attempts become Runs w
 
 ### `/sc plan`
 
-- `task --add|--list|--show|--run|--audit|--cancel|--retry`
+- `task --add|--list|--show|--run|--audit|--cancel|--retry|--next|--start [TASK-NNN]`
 - `sprint --add|--list|--show|--start|--complete|--block`
 - `feature --add|--list|--show|--activate|--complete`
-- `run --list|--show|--authorize-mutation|--record-mutation|--satisfy-guardrail|--validate|--learn|--complete|--resume|--fail|--block`
-- `intake <request>`
+- `run --list|--show|--render|--stats|--normalize-legacy|--authorize-mutation|--record-mutation|--satisfy-guardrail|--validate|--learn|--complete [--summary "…"]|--resume|--fail|--block`
+- `intake <request> [--type fix|task|feature|docs|discovery] [--preview "…"]`
 - `challenge <question>`
 
 ### `/sc knowledge`

package/DECISIONS.md

@@ -350,3 +350,23 @@ Date: 2026-07-22
 **Consequences** — Normal queries stay fast while content remains the final verifier. State and intake share one canonical fingerprint implementation. Cost: metadata-only touches may trigger one full verification, and scanner changes require a cache-schema bump.
 
 **Alternatives considered** — Hash every source on every query: maximally simple but O(project) on the hot path. Timestamp-only cache validity: faster but allows derived metadata to masquerade as truth.
+
+---
+
+## ADR-025 — v1 compatibility cycle sunset target
+Status: accepted
+Date: 2026-08-20
+
+**Context** — Since the 2.0.0 release (2026-07-21), ScrumRun carries a v1 compatibility surface: generated command aliases (`sc-backlog`, `sc-know`, `sc-sprint`, etc.), v1 layout files (`golden-rules.md`, `backlog.md`, `knowledge.md`, `goals/main/`), the v1 `runGuardrails`/`renderState` builders, and the `migrateLegacyProject` pre-`.scrumrun` layout migration. SPEC §12 states these "may remain for one compatibility cycle" but never defines when that cycle ends. This creates ongoing maintenance cost (the `bin/scrumrun.js` monolith carries ~1200 lines of v1 code), ambiguity about which files are canonical, and a wider attack surface for secret/path bugs.
+
+**Decision** — Target the next major version (3.0.0) as the hard sunset for v1 compatibility. Until then:
+
+1. `doctor` emits a `warning` finding (`V1_COMPAT_IN_USE`) when it detects v1 aliases, v1 layout files, or the legacy layout migration trigger, so maintainers can track remaining v1 usage.
+2. The CHANGELOG and README gain a deprecation notice pointing to `npx scrumrun@latest update --migrate`.
+3. No new v1 features are added; v1 code is frozen and only receives security fixes.
+
+At 3.0.0: v1 aliases are removed, v1 layout files are no longer auto-created, `migrateLegacyProject` and the v1 builders are deleted, and the bin file is refactored to route only `/sc` commands.
+
+**Consequences** — Clear end date for v1 code; maintainers can plan the bin refactor and deletion with confidence. Users on v1 have a full major-version cycle to migrate using the existing idempotent, reversible `migrate --to 2 --apply` tooling. Cost: the v1 surface remains in the tarball until 3.0.0, so the bin monolith and v1 tests are not yet removable.
+
+**Alternatives considered** — Keep v1 forever: maintenance burden grows and the canonical surface stays diluted. Hard-cut immediately (2.6.0): breaks users who have not migrated and gives no warning. Remove v1 code now behind a flag: adds complexity to an already large bin file without a clear deadline.

package/README.md

@@ -4,7 +4,7 @@
 
 ScrumRun gives an agent a small command surface and a precise project memory: what should be done, how each attempt happened, which decisions constrain the code, and why the architecture exists in its current form.
 
-**Package:** `2.5.1` · **Method target:** `2.0.0` · **Runtime:** Node.js `>=22.13.0` · **License:** MIT
+**Package:** `2.6.0` · **Method target:** `2.0.0` · **Runtime:** Node.js `>=22.13.0` · **License:** MIT
 
 **New here?** Read the [Quickstart](docs/QUICKSTART.md) — first Run in under 10 minutes, no `SPEC.md` reading required. Full docs map in [`docs/INDEX.md`](docs/INDEX.md).
 
@@ -65,13 +65,15 @@ RECEIVED → CONTEXTUALIZING → POLICY → RISK → CLASSIFICATION
          → PLANNING → AWAITING_APPROVAL
 ```
 
+The agent may assert the classification (`--type fix|task|feature|docs|discovery`) and attach a short technical preview (`--preview "…"`), rendered with color in the terminal before any Task exists. Nothing canonical is persisted before approval.
+
 Explicit approval atomically creates a Task and a Run. Execution then follows:
 
 ```text
 EXECUTING → VALIDATING → LEARNING → COMPLETED | FAILED | BLOCKED
 ```
 
-Nothing canonical is persisted before approval. Failed retries remain available as separate Runs.
+Every approved Task carries an `## Acceptance Criteria` section so "done" is defined before work begins; `--complete --summary "…"` stores a `## Technical Summary` on the Run so the next agent inherits what was actually done. Failed retries remain available as separate Runs.
 
 Each Run contains a machine-validated event ledger. Events have stable ids such as `RUN-044-EVT-003`, RFC3339 timestamps, actors, reasons, and typed evidence for commands, tests, files, reviews, decisions, insights, and risks. Run is the only operational history; Task keeps its approved scope and synchronized current status without duplicating those events. Completion is rejected when validation or learning evidence is missing.
 
@@ -114,6 +116,21 @@ The fast graph/search layer is `.scrumrun/.cache/semantic-index.sqlite`. It is i
 
 `map.md` is shown only when its source fingerprint matches the current semantic index. A fresh placeholder or stale map is rejected with an explicit rebuild instruction instead of being presented as project truth.
 
+## Project briefing
+
+`state.md` is the **briefing**: a bounded summary an agent reads first, before touching anything else.
+
+```text
+## Now            active work, with each Task's assignee
+## Recent         last completions + their technical summaries
+## Open Decisions titles only, with pointers
+## Active Memory  confirmed facts / insights / decisions
+## Next Up        the backlog queue, oldest first
+## Where to look  pointers to guardrails, tasks, runs, semantic search
+```
+
+It is progressive disclosure: the briefing is enough for most work; the agent follows its pointers and goes deeper only when the briefing lacks what it needs. The intake context package embeds the same briefing. Each agent declares an identity (`SCRUMRUN_AGENT` or `Agent Identity` in `config.md`), recorded as the Task `assignee` and Run `actor`, so `--shared` teams can see who owns each active Task from the briefing alone.
+
 ## Migrating an ongoing v1 project
 
 Update the client integrations and automatically run a read-only migration preflight:
@@ -208,9 +225,16 @@ Rules:
 npx scrumrun@latest commands
 
 # plan without writes, then approve the emitted token
-npx scrumrun@latest sc plan intake "Fix pricing rounding"
+npx scrumrun@latest sc plan intake "Fix pricing rounding" --type fix --preview "Rounding moved after tax calc"
 npx scrumrun@latest sc plan intake --approve <token>
 
+# record what was done at completion, so the next agent inherits it
+npx scrumrun@latest sc plan run --complete RUN-001 --note "Done" --evidence "npm test: passed" --summary "Moved rounding after tax calc in checkout/pricing.ts"
+
+# auto-sequencing: surface and start the next backlog Task
+npx scrumrun@latest sc plan task --next
+npx scrumrun@latest sc plan task --start TASK-009
+
 # authorize and record a material source mutation
 npx scrumrun@latest sc plan run --authorize-mutation RUN-001 --path src/pricing.ts
 npx scrumrun@latest sc plan run --record-mutation RUN-001 --permit MUT-... --note "Pricing change recorded"

package/SPEC.md

@@ -83,6 +83,8 @@ method: 2.0.0
 
 IDs, filenames, kind, status, real ISO dates, and method version must agree. Unknown fields and authored prose are preserved. Duplicate fields, malformed frontmatter, unsafe paths, and symlinked canonical paths are invalid.
 
+A Task may carry an optional `assignee` scalar recording the agent identity (`SCRUMRUN_AGENT` or `config.md` `Agent Identity`) that owns the work. It is descriptive metadata, never a competing authority: it does not change status transitions or block conformance.
+
 ### 3.2 Stable identifiers
 
 | Kind | Identifier |
@@ -202,7 +204,11 @@ Approval atomically creates one Task and its first Run. If either write fails, n
 
 The approved Run binds the exact Guardrail-policy fingerprint and a canonical workspace baseline. Every post-approval `deferred` check becomes an append-only Guardrail obligation. A material source mutation requires a short-lived, path-scoped permit issued from that baseline; recording it verifies before/after hashes, policy freshness, path scope, read-only boundaries, symlink safety, and newly introduced secret-like content. Unrecorded workspace drift fails closed. A Run cannot complete while an obligation is unresolved or the workspace differs from its last recorded mutation.
 
-Run transitions synchronously update the linked Task and append exactly one structured event to the Run ledger. Validation, learning, completion, failure, block, and resume transitions require a reason or typed evidence. Task status changes without receiving a duplicate narrative history. Multi-file mutations use a durable local transaction journal: `prepared` operations roll back byte-exactly after failure/interruption, while `committed` journals are verified and finalized. Ordinary audit is read-only and reports pending recovery; `doctor --recover` or retrying the approved mutation performs recovery explicitly. Entering `learning` may extract structured candidates from the Run, but extraction failure never blocks Run progress.
+The agent may assert the classification explicitly (`--type fix|task|feature|docs|discovery`), overriding keyword inference with validation and a stable reason. It may attach a short technical preview (`--preview`), rendered in the terminal, bound into the approval token, and stored as `## Preview` on the approved Task. A Task declares its `## Acceptance Criteria` before execution; completion is measured against them, never against elapsed time or token budget.
+
+Run transitions synchronously update the linked Task and append exactly one structured event to the Run ledger. Validation, learning, completion, failure, block, and resume transitions require a reason or typed evidence. Task status changes without receiving a duplicate narrative history. On completion, an optional `## Technical Summary` section records what was actually done, surfaced to later intake through the briefing. Multi-file mutations use a durable local transaction journal: `prepared` operations roll back byte-exactly after failure/interruption, while `committed` journals are verified and finalized. Ordinary audit is read-only and reports pending recovery; `doctor --recover` or retrying the approved mutation performs recovery explicitly. Entering `learning` may extract structured candidates from the Run, but extraction failure never blocks Run progress.
+
+Backlog is a queue view of Tasks with `status: backlog`, ordered oldest-first by id. Starting a backlog Task (`--next` to surface, `--start` to promote) transitions `backlog → running`, creates the Task's first Run, re-evaluates policy, and records the agent identity. Starting is itself the explicit approval required by I-01.
 
 ## 6. Policy and precedence
 
@@ -252,6 +258,8 @@ The agreed v1 control-context baseline is 48,000 characters. A fresh lean v2 int
 
 `state.md`, `map.md`, context packages, and `.cache/semantic-index.sqlite` are non-authoritative projections. They carry source fingerprints or are treated as stale. `state.md` uses the exact canonical fingerprint bound into intake, plus a projection schema, RFC3339 generation time, and a disposable watch fingerprint. SQLite stores its source and watch fingerprints with an explicit cache schema.
 
+`state.md` is the **briefing**: a bounded, progressive-disclosure index of active work (with each Task's `assignee`), recent completions (with their technical summaries), open decisions, active memory, and the backlog queue, plus pointers to deeper artifacts. Agents read the briefing first and follow its pointers, going deeper only when the briefing lacks what they need. The briefing is a convenience view, never authority; a canonical artifact the briefing summarizes remains the source of truth.
+
 Freshness checks use a two-tier strategy: unchanged path/stat identity proves that no source read or reparse is needed; changed metadata triggers a complete canonical/source content fingerprint before staleness is asserted. Cache metadata may optimize verification but never supplies project truth. A cache-schema mismatch forces one disposable rebuild. Deleting `.cache/` must not remove authored knowledge, and rebuilding it from unchanged sources must yield equivalent query results.
 
 The index must never scan or store `vault.local.md`. Source scanning is bounded, skips dependencies/build output and symlinks, and uses replaceable language adapters.

package/bin/scrumrun.js

@@ -1,5 +1,17 @@
 #!/usr/bin/env node
 
+(function checkNodeVersion() {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  if (major < 22 || (major === 22 && minor < 13)) {
+    process.stderr.write(
+      `SR-E-501 Unsupported Node.js runtime: ${process.versions.node}. `
+      + `ScrumRun requires Node.js >=22.13.0 for native SQLite. `
+      + `Upgrade Node and retry.\n`
+    );
+    process.exit(1);
+  }
+})();
+
 const crypto = require("crypto");
 const fs = require("fs");
 const path = require("path");
@@ -19,7 +31,7 @@ const { ARTIFACT_TYPES, ArtifactRepository } = require(path.join(root, "lib", "v
 const { aliases: COMMAND_ALIASES, resolveAlias, resolveRoute } = require(path.join(root, "lib", "commands", "manifest"));
 const { renderCommandHelp, renderCompatibilityPrompt, renderRootPrompt } = require(path.join(root, "lib", "commands", "render"));
 const { planRequest } = require(path.join(root, "lib", "runtime", "request-engine"));
-const { approveRequest, refreshState, retryTask, transitionRun } = require(path.join(root, "lib", "runtime", "orchestrator"));
+const { approveRequest, nextBacklogTask, refreshState, retryTask, startBacklogTask, transitionRun } = require(path.join(root, "lib", "runtime", "orchestrator"));
 const { authorizeMutation, recordMutation, satisfyGuardrail } = require(path.join(root, "lib", "runtime", "mutation-gateway"));
 const { recordArtifactReview } = require(path.join(root, "lib", "runtime", "review-service"));
 const { createMemory, listMemory, showMemory, transitionMemory } = require(path.join(root, "lib", "memory", "service"));
@@ -331,6 +343,14 @@ function migrationPreflightOnUpdate({ apply = false } = {}) {
 function updateInstallation(target, { migrate = false } = {}) {
   const migration = migrationPreflightOnUpdate({ apply: migrate });
   install(target, true, { compatibility: true });
+  if (migrate && v2Project()) {
+    try {
+      refreshState(path.join(process.cwd(), ".scrumrun"));
+    } catch {
+      // Best-effort: regenerating the disposable briefing must never block an integration update.
+      // Conformance reports stale or unsafe state separately.
+    }
+  }
   return migration;
 }
 
@@ -1212,15 +1232,17 @@ function runTransitionOptions(args) {
   let note = null;
   let actor = "agent";
   let occurredAt = null;
+  let summary = null;
   for (let index = 2; index < args.length; index++) {
     const token = args[index];
     const value = args[index + 1] && !args[index + 1].startsWith("--") ? args[index + 1] : null;
-    if (token === "--note" || token === "--actor" || token === "--at" || token === "--evidence" || evidenceFlags.has(token)) {
+    if (token === "--note" || token === "--actor" || token === "--at" || token === "--evidence" || token === "--summary" || evidenceFlags.has(token)) {
       if (!value) throw new Error(`${token} requires a value.`);
       index++;
       if (token === "--note") note = value;
       else if (token === "--actor") actor = value;
       else if (token === "--at") occurredAt = value;
+      else if (token === "--summary") summary = value;
       else if (token === "--evidence") {
         const separator = value.indexOf(":");
         const kind = separator > 0 ? value.slice(0, separator) : "note";
@@ -1235,7 +1257,7 @@ function runTransitionOptions(args) {
     if (token.startsWith("--")) throw new Error(`Unknown Run evidence option: ${token}`);
     noteParts.push(token);
   }
-  return { note: note || noteParts.join(" ").trim() || null, evidence, actor, occurredAt };
+  return { note: note || noteParts.join(" ").trim() || null, evidence, actor, occurredAt, summary };
 }
 
 function removeOptionPairs(args, names) {
@@ -1349,15 +1371,19 @@ function executeRootRoute(route) {
       console.log(`${result.status === "already-approved" ? "Already approved" : "Approved"}: ${result.task.id} → ${result.run.id}`);
       return;
     }
-    const request = routeArgs[0] === "--request" ? routeArgs.slice(1).join(" ") : routeArgs.join(" ");
-    const plan = planRequest(process.cwd(), request);
+    const typeOverride = optionValue(routeArgs, "--type");
+    const preview = optionValue(routeArgs, "--preview");
+    const cleanArgs = removeOptionPairs(routeArgs, ["--type", "--preview"]);
+    const startIndex = cleanArgs[0] === "--request" ? 1 : 0;
+    const request = cleanArgs.slice(startIndex).filter((arg) => !arg.startsWith("--")).join(" ").trim();
+    const plan = planRequest(process.cwd(), request, { typeOverride, preview });
     if (routeArgs.includes("--json")) {
       console.log(JSON.stringify(plan, null, 2));
       return;
     }
     const { canRenderPretty, renderIntake, renderIntakePlain } = require(path.join(root, "lib", "commands", "pretty-intake"));
     const forcePlain = routeArgs.includes("--plain");
-    if (!forcePlain && canRenderPretty()) {
+    if (!forcePlain && process.stdout.isTTY && canRenderPretty()) {
       console.log(renderIntake(plan));
     } else {
       console.log(renderIntakePlain(plan));
@@ -1370,6 +1396,33 @@ function executeRootRoute(route) {
     console.log(`Created retry ${result.run.id} for ${result.task.id} (attempt ${result.run.attempt}).`);
     return;
   }
+  if (noun === "plan" && subject === "task" && routeArgs[0] === "--next") {
+    const repository = new ArtifactRepository(projectFile());
+    const next = nextBacklogTask(repository);
+    if (!next) {
+      console.log("No backlog Tasks to start.");
+      return;
+    }
+    console.log(`Next backlog Task: ${next.id} — ${next.title || next.id}`);
+    console.log(`Start it with: scrumrun sc plan task --start ${next.id}`);
+    return;
+  }
+  if (noun === "plan" && subject === "task" && routeArgs[0] === "--start") {
+    let target = routeArgs[1];
+    if (!target) {
+      const repository = new ArtifactRepository(projectFile());
+      const next = nextBacklogTask(repository);
+      if (!next) {
+        console.error("No backlog Tasks to start.");
+        process.exitCode = 1;
+        return;
+      }
+      target = next.id;
+    }
+    const result = startBacklogTask(process.cwd(), target);
+    console.log(`Started ${result.task.id} (${result.run.id}) assigned to ${result.task.assignee || "agent"}.`);
+    return;
+  }
   if (noun === "plan" && subject === "run" && routeArgs[0] === "--render") {
     const { renderRunFromDisk } = require(path.join(root, "lib", "commands", "run-render"));
     const runId = routeArgs[1];

package/lib/commands/manifest.js

@@ -6,7 +6,7 @@ const nouns = Object.freeze({
   plan: {
     description: "turn intent into Features, Tasks, Sprints, and Runs",
     subjects: {
-      task: ["--add [--type fix] [--status backlog]", "--list", "--show", "--run", "--audit", "--cancel", "--retry"],
+      task: ["--add [--type fix] [--status backlog]", "--list", "--show", "--run", "--audit", "--cancel", "--retry", "--next", "--start [TASK-NNN]"],
       sprint: ["--add", "--list", "--show", "--start", "--complete", "--block"],
       feature: ["--add", "--list", "--show", "--activate", "--complete"],
       run: [
@@ -20,12 +20,12 @@ const nouns = Object.freeze({
         "--satisfy-guardrail <RUN-NNN> --guardrail <GR-NNN> [--note] [--evidence] [--review] [--migration] [--actor]",
         "--validate [--note] [--evidence] [--command] [--test] [--file] [--review] [--actor] [--at]",
         "--learn [--note] [--evidence] [--decision] [--insight] [--file] [--actor] [--at]",
-        "--complete [--note] [--evidence] [--review] [--test] [--file] [--actor] [--at]",
+        "--complete [--note] [--evidence] [--review] [--test] [--file] [--actor] [--at] [--summary \"technical recap for future tasks\"]",
         "--resume [--note] [--evidence] [--risk] [--actor] [--at]",
         "--fail [--note] [--evidence] [--risk] [--test] [--actor] [--at]",
         "--block [--note] [--evidence] [--risk] [--actor] [--at]"
       ],
-      intake: ["<request>", "--request", "--approve", "--plain", "--json"],
+      intake: ["<request>", "--request", "--approve", "--plain", "--json", "--type <fix|task|feature|docs|discovery>", "--preview \"technical summary\""],
       challenge: ["<question>"]
     }
   },

package/lib/commands/pretty-intake.js

@@ -211,6 +211,9 @@ function renderIntake(plan) {
   const classificationText = classificationLabel(plan.classification);
   lines.push(...fieldLine("Classification", classificationText, width, ACID_FG));
   lines.push(...fieldLine("Why", plan.classification.reason, width, FG.gray));
+  if (plan.preview) {
+    lines.push(...fieldLine("Preview", plan.preview, width, FG.cyan));
+  }
   const riskColor = RISK_TONE[plan.risk.level] || FG.white;
   lines.push(...fieldLine("Risk", `${plan.risk.level} · ${plan.risk.reasons.join("; ")}`, width, riskColor));
 
@@ -258,6 +261,7 @@ function renderIntakePlain(plan) {
   lines.push("# ScrumRun Intake");
   lines.push(`State: ${plan.state}`);
   lines.push(`Classification: ${plan.classification.type} (${plan.classification.reason})`);
+  if (plan.preview) lines.push(`Preview: ${plan.preview}`);
   lines.push(`Risk: ${plan.risk.level} — ${plan.risk.reasons.join("; ")}`);
   lines.push(`Policy: ${plan.policy.status} (${plan.policy.checked.length} checked; ${plan.policy.deferred.length} deferred)`);
   for (const violation of plan.policy.violations || []) lines.push(`BLOCKED: ${violation}`);

package/lib/runtime/briefing.js

@@ -0,0 +1,104 @@
+"use strict";
+
+const { ARTIFACT_TYPES } = require("../v2/schema");
+const { ArtifactRepository } = require("../v2/artifacts");
+const { artifactSnapshot, canonicalFingerprint, canonicalWatchSnapshot } = require("./canonical-snapshot");
+const { extractTechnicalSummary } = require("./run-ledger");
+
+const TERMINAL = new Set(["completed", "failed", "cancelled", "resolved", "rejected", "deprecated", "invalidated", "archived", "passed"]);
+
+function briefLine(record, kind) {
+  const marker = record.status === "completed" || record.status === "passed" || record.status === "resolved" ? "\u2713" : record.status === "failed" ? "\u2717" : "\u2022";
+  return `- ${record.id} ${marker} ${record.title || record.id}`;
+}
+
+function generateBriefing(scrumDir, repository) {
+  const repo = repository || new ArtifactRepository(scrumDir);
+  const snapshot = artifactSnapshot(scrumDir);
+  const sourceFingerprint = canonicalFingerprint(scrumDir, snapshot.hashes);
+  const watch = canonicalWatchSnapshot(scrumDir);
+
+  const activeWork = ["feature", "task", "sprint", "run", "review"]
+    .flatMap((kind) => (snapshot.records[kind] || [])
+      .filter((r) => r.id && !TERMINAL.has(r.status))
+      .map((r) => r.assignee && r.assignee !== "agent"
+        ? `- ${r.id} | ${r.status} | ${r.assignee} | ${r.title || r.id}`
+        : `- ${r.id} | ${r.status} | ${r.title || r.id}`))
+    .slice(0, 5);
+
+  const completedRuns = (snapshot.records.run || [])
+    .filter((r) => r.status === "completed")
+    .slice(-5)
+    .reverse();
+
+  const recentLines = [];
+  for (const run of completedRuns.slice(0, 3)) {
+    const artifact = repo.read("run", run.id);
+    const summary = artifact ? extractTechnicalSummary(artifact.body) : null;
+    const text = summary ? summary.slice(0, 120) : (run.title || run.id);
+    recentLines.push(`- ${run.id} \u2713 ${text}`);
+  }
+
+  const openDecisions = (snapshot.records.decision || [])
+    .filter((r) => r.status === "open")
+    .slice(-5)
+    .map((r) => `- ${r.id} \u2014 ${r.title || r.id}`);
+
+  const activeMemory = [
+    ...(snapshot.records.knowledge || []).filter((r) => r.status === "approved").slice(-3),
+    ...(snapshot.records.insight || []).filter((r) => r.status === "confirmed").slice(-3),
+    ...(snapshot.records.decision || []).filter((r) => r.status === "resolved").slice(-3)
+  ].map((r) => `- ${r.id} \u2014 ${r.title || r.id} (${r.status})`);
+
+  const backlogTasks = (snapshot.records.task || [])
+    .filter((r) => r.status === "backlog")
+    .slice(0, 3)
+    .map((r) => `- ${r.id} \u2014 ${r.title || r.id}`);
+
+  const counts = {};
+  for (const kind of Object.keys(ARTIFACT_TYPES)) {
+    counts[kind] = (snapshot.records[kind] || []).length;
+  }
+
+  const content = `# ScrumRun Briefing
+
+Projection schema: 2
+Generated: ${new Date().toISOString()}
+Source fingerprint: ${sourceFingerprint}
+Watch fingerprint: ${watch.fingerprint}
+Authority: none; rebuild from canonical artifacts.
+Progressive disclosure: read this first; go deeper only if the briefing lacks what you need.
+
+## Now
+
+${activeWork.length ? activeWork.join("\n") : "- No active canonical work."}
+
+## Recent
+
+${recentLines.length ? recentLines.join("\n") : "- No completed Runs."}
+
+## Open Decisions
+
+${openDecisions.length ? openDecisions.join("\n") : "- None."}
+
+## Active Memory
+
+${activeMemory.length ? activeMemory.slice(0, 5).join("\n") : "- No active canonical memory."}
+
+## Next Up
+
+${backlogTasks.length ? backlogTasks.join("\n") : "- No backlog Tasks."}
+
+## Where to look
+
+- Guardrails: .scrumrun/guardrails.md
+- Tasks: .scrumrun/tasks/ (${counts.task || 0} total)
+- Runs: .scrumrun/runs/ (${counts.run || 0} total)
+- Semantic: sc knowledge study "<topic>" for deep queries
+- Full state: rebuild with sc config doctor --recover
+`;
+
+  return { content, sourceFingerprint, watchFingerprint: watch.fingerprint, sourceFiles: watch.files };
+}
+
+module.exports = { TERMINAL, generateBriefing };

package/lib/runtime/canonical-snapshot.js

@@ -35,7 +35,8 @@ function artifactSnapshot(scrumDir) {
         title: ((artifact.body || "").match(/^# ([^\r\n]+)/m) || [])[1] || artifact.record.id,
         task: artifact.record.task || null,
         sprint: artifact.record.sprint || null,
-        feature: artifact.record.feature || null
+        feature: artifact.record.feature || null,
+        assignee: artifact.record.assignee || null
       } : { id: path.basename(artifact.file, ".md"), status: "invalid", errors: artifact.errors };
     });
   }

package/lib/runtime/context.js

@@ -6,6 +6,9 @@ const { readProjectModel } = require("../v2/project-store");
 const { containsSecret } = require("../security/secrets");
 const { parseGuardrails } = require("./policy-engine");
 const { artifactSnapshot, canonicalFingerprint } = require("./canonical-snapshot");
+const { ArtifactRepository } = require("../v2/artifacts");
+const { extractTechnicalSummary } = require("./run-ledger");
+const { generateBriefing } = require("./briefing");
 
 const EXCLUDED_ROOT_ENTRIES = new Set([".git", ".scrumrun", "node_modules", "dist", "build", "coverage"]);
 
@@ -43,6 +46,18 @@ function projectScan(projectRoot) {
 
 const guardrailRecords = parseGuardrails;
 
+function recentTechnicalSummaries(scrumDir, runRecords, limit = 5) {
+  const repository = new ArtifactRepository(scrumDir);
+  const summaries = [];
+  for (const run of (runRecords || []).filter((r) => r.status === "completed").slice(0, limit)) {
+    const artifact = repository.read("run", run.id);
+    if (!artifact || !artifact.body) continue;
+    const summary = extractTechnicalSummary(artifact.body);
+    if (summary) summaries.push({ run: run.id, summary: capped(summary, 500) });
+  }
+  return summaries;
+}
+
 function contextFingerprint(scrumDir, artifactHashes) {
   return canonicalFingerprint(scrumDir, artifactHashes);
 }
@@ -66,6 +81,7 @@ function buildContextPackage(projectRoot, request) {
   const artifacts = model.source === "canonical-v2" ? artifactSnapshot(scrumDir) : { records: {}, hashes: [], warnings: [] };
   const openDecisions = (artifacts.records.decision || []).filter((record) => record.status === "open").slice(-10);
   const recentRuns = (artifacts.records.run || []).slice(-10).reverse();
+  const recentSummaries = recentTechnicalSummaries(scrumDir, recentRuns);
   const activeWork = ["feature", "task", "sprint", "run"].flatMap((kind) =>
     (artifacts.records[kind] || []).filter((record) => !["completed", "failed", "cancelled"].includes(record.status))
   ).slice(0, 50);
@@ -83,11 +99,12 @@ function buildContextPackage(projectRoot, request) {
     layout: model.layout,
     source: model.source,
     fingerprint,
+    briefing: capped(generateBriefing(scrumDir).content, 2000),
     projectScan: projectScan(projectRoot),
     guardrails: guardrailRecords(guardrailsContent).filter((record) => record.status === "active").slice(0, 100),
     config,
     project: project || "[missing]",
-    history: { recentRuns },
+    history: { recentRuns, recentSummaries },
     decisions: { open: openDecisions },
     activeWork,
     graph: {