dorfl 0.1.0 → 0.1.2

package/src/surface-gate.ts

@@ -6,7 +6,7 @@ import {parseableJsonContractPrompt} from './review-verdict.js';
 import type {NewQuestion} from './sidecar.js';
 
 /**
- * The **SURFACE gate** (prd `advance-loop`, task `advance-rung-surface`,
+ * The **SURFACE gate** (spec `advance-loop`, task `advance-rung-surface`,
  * US #32/33) — the surface-question rung's fresh-context spawn, the DIRECT mirror
  * of the PR/code review gate ({@link import('./review-gate.js')}). On
  * `classify=surface`, the advance engine spawns a FRESH-CONTEXT agent with the
@@ -70,7 +70,7 @@ export interface SurfaceEmit {
 
 /** What the surface gate needs to launch a fresh-context surface of one item. */
 export interface SurfaceGateInput {
-	/** The namespaced identity the surface is for (`task:foo` / `prd:bar` / `observation:baz`). */
+	/** The namespaced identity the surface is for (`task:foo` / `spec:bar` / `observation:baz`). */
 	item: string;
 	/** The working clone/checkout the gate runs in. */
 	cwd: string;

package/src/surface-persist.ts

@@ -13,7 +13,7 @@ import {
 } from './sidecar.js';
 
 /**
- * The engine-owned SURFACE PERSIST (prd `advance-loop`, task
+ * The engine-owned SURFACE PERSIST (spec `advance-loop`, task
  * `advance-rung-surface`, US #15/33) — the half of the surface rung the ENGINE
  * owns (the skill JUDGES, the engine PERSISTS). Given the questions the
  * `surface-questions` skill EMITTED (gathered by `surface-gate.ts`'s spawn), the
@@ -53,7 +53,7 @@ import {
 export interface SurfacePersistOptions {
 	/** Working clone/worktree the persist commits in. */
 	cwd: string;
-	/** The namespaced item identity (`task:foo` / `prd:bar` / `observation:baz`). */
+	/** The namespaced item identity (`task:foo` / `spec:bar` / `observation:baz`). */
 	item: string;
 	/**
 	 * The item file path RELATIVE to `cwd` (e.g. `work/backlog/foo.md`). The

package/src/tasker-review-loop.ts

@@ -29,9 +29,9 @@ export {parseReviewVerdict as parseTaskReviewVerdict} from './review-verdict.js'
 
 /**
  * **The tasker review→edit→re-review→converge LOOP** (`slicer-review-edit-loop`,
- * GATES prd `work/prds/ready/review.md` RESOLVED DESIGN — Shape 2 / insertion point A).
+ * GATES spec `work/specs/ready/review.md` RESOLVED DESIGN — Shape 2 / insertion point A).
  *
- * On the `do prd:<slug>` tasking path (`tasking.ts`/`performTask`), AFTER the
+ * On the `do spec:<slug>` tasking path (`tasking.ts`/`performTask`), AFTER the
  * agent produces a candidate set of `work/tasks/backlog/<slug>.md` tasks and BEFORE the
  * runner finalises/lands them, this loop RUNS the `review` SKILL
  * (`skills/review/SKILL.md`), APPLIES its findings as EDITS to the candidate task
@@ -47,7 +47,7 @@ export {parseReviewVerdict as parseTaskReviewVerdict} from './review-verdict.js'
  *     N so the loop can never run forever.
  *
  *     ⚠️ ASPIRATION-VS-BUILT (2026-06-10): the "single context" wording above is the
- *     prd's ASPIRATION, NOT what this module does at runtime. The ACTUAL N loop is
+ *     spec's ASPIRATION, NOT what this module does at runtime. The ACTUAL N loop is
  *     RUNNER-DRIVEN and PER-PASS: `runOneExecution` does `for (pass …) { gate(…);
  *     applyEdits(…to disk…) }` — ONE agent LAUNCH per pass, the runner writing the
  *     agent's edits to the candidate task FILES (`work/tasks/backlog/`) between passes, the
@@ -75,7 +75,7 @@ export {parseReviewVerdict as parseTaskReviewVerdict} from './review-verdict.js'
  *   - **a specific uncertain task** → emit it `needsAnswers: true` with the
  *     questions in its body (created, not agent-buildable until a human answers).
  *   - **the whole decomposition unclear / `taskerLoopMax` exhausted with blockers** →
- *     route the prd to `work/needs-attention/<slug>.md` with the questions as the
+ *     route the spec to `work/needs-attention/<slug>.md` with the questions as the
  *     reason, emitting NO guessed tasks.
  *
  * The verdict sink itself (the git transitions for those three outcomes) is the
@@ -101,7 +101,7 @@ export type TaskReviewVerdict = ReviewVerdict;
 
 /** What the review gate needs to launch a fresh-context review+edit pass. */
 export interface TaskReviewGateInput {
-	/** The prd slug whose candidate tasks are under review. */
+	/** The spec slug whose candidate tasks are under review. */
 	slug: string;
 	/** The working clone/checkout the loop runs in (candidate tasks live here). */
 	cwd: string;
@@ -141,7 +141,7 @@ export type LoopOutcome =
 	| 'converged'
 	/** `taskerLoopMax` hit with blockers → specific uncertain task(s) → needsAnswers. */
 	| 'uncertain-tasks'
-	/** `taskerLoopMax` hit / decomposition unclear → route the prd to needs-attention. */
+	/** `taskerLoopMax` hit / decomposition unclear → route the spec to needs-attention. */
 	| 'decomposition-unclear';
 
 /** The result of running the loop — the disposition the caller's sink routes. */
@@ -174,7 +174,7 @@ export interface RunTaskReviewLoopResult {
 }
 
 export interface RunTaskReviewLoopOptions {
-	/** The prd slug whose candidate tasks are being improved. */
+	/** The spec slug whose candidate tasks are being improved. */
 	slug: string;
 	/** The working clone/checkout the loop runs in. */
 	cwd: string;
@@ -226,7 +226,7 @@ export interface RunTaskReviewLoopOptions {
  * to the candidate task files, then re-review — until `verdict === 'approve'` (no
  * NEW blocking issue → converged) or the pass count reaches `taskerLoopMax`. On the cap
  * with a still-`block` verdict, ROUTE per the verdict's channels:
- *   - `decompositionUnclear` set ⇒ `decomposition-unclear` (prd → needs-attention,
+ *   - `decompositionUnclear` set ⇒ `decomposition-unclear` (spec → needs-attention,
  *     no guessed tasks);
  *   - else `uncertainTasks` (or, as a floor, every candidate task) ⇒
  *     `uncertain-tasks` (those tasks emitted `needsAnswers: true` + questions).
@@ -296,7 +296,7 @@ export async function runTaskReviewLoop(
 		note(
 			`Tasker review loop did not converge within taskerLoopMax=${taskerLoopMax} ` +
 				`across ${executions} fresh context(s); the whole decomposition is ` +
-				'unclear — routing the prd to needs-attention (no guessed tasks).',
+				'unclear — routing the spec to needs-attention (no guessed tasks).',
 		);
 		return {
 			outcome: 'decomposition-unclear',
@@ -308,7 +308,7 @@ export async function runTaskReviewLoop(
 			message:
 				`The decomposition of '${options.slug}' is still unclear after ` +
 				`taskerLoopMax=${taskerLoopMax} review pass(es) across ${executions} fresh ` +
-				'context(s); routing the prd to needs-attention with the open ' +
+				'context(s); routing the spec to needs-attention with the open ' +
 				'questions, emitting no guessed tasks.',
 		};
 	}
@@ -617,18 +617,18 @@ export function buildTaskReviewPrompt(input: TaskReviewGateInput): string {
 	const list = input.candidateTasks.map((p) => `  - ${p}`).join('\n');
 	return [
 		`You are a FRESH-CONTEXT reviewer in the TASKER review→edit→converge LOOP`,
-		`(insertion point A). Review the CANDIDATE TASKS just produced for the prd`,
+		`(insertion point A). Review the CANDIDATE TASKS just produced for the spec`,
 		`"${input.slug}":`,
 		list || '  (no candidate tasks found)',
 		``,
 		reviewDisciplinePrompt(),
 		``,
-		`Read the source prd (work/prds/ready/${input.slug}.md) and review the candidate`,
+		`Read the source spec (${workItemRel('specs-ready', `${input.slug}.md`)}) and review the candidate`,
 		`decomposition ADVERSARIALLY. Review the WHOLE SET — graph coherence / gaps /`,
 		`overlap / goal-composition (dependency-graph coherence, set-level gaps,`,
-		`overlapping/duplicated tasks, and "does the set compose into the prd goal")`,
+		`overlapping/duplicated tasks, and "does the set compose into the spec goal")`,
 		`— not just per-task well-formedness. The DESTINATION CHECK ("if every task`,
-		`is built exactly as written, do we end up with the system the prd describes?")`,
+		`is built exactly as written, do we end up with the system the spec describes?")`,
 		`is PART OF this pass and may ITSELF trigger edits — that is why this is a`,
 		`loop, not a one-shot gate.`,
 		``,
@@ -645,7 +645,7 @@ export function buildTaskReviewPrompt(input: TaskReviewGateInput): string {
 		`    can FIX a finding by editing (the natural improver step).`,
 		`  - "uncertainTasks" — specific tasks you cannot make buildable (each gets`,
 		`    \`needsAnswers: true\` with the questions in its body).`,
-		`  - "decompositionUnclear" — the WHOLE decomposition is unsound (the prd is`,
+		`  - "decompositionUnclear" — the WHOLE decomposition is unsound (the spec is`,
 		`    routed to needs-attention; emit no guessed tasks).`,
 		`Do NOT fill "review" / "edit" / "questions" — those are other callers'`,
 		`channels. Flag, do not guess: a flagged question costs one human glance; a`,

package/src/tasking-eligibility.ts

@@ -1,46 +1,46 @@
 /**
  * Pure tasking-eligibility resolution — the auto-task decision layer, one level
- * UP from the build gate (`eligibility.ts`). No I/O: callers pass in the prd's
+ * UP from the build gate (`eligibility.ts`). No I/O: callers pass in the spec's
  * two autonomy axes (`humanOnly`, `needsAnswers`), the repo's `autoTask` policy,
- * the prd's `taskedAfter` slugs, and the set of slugs whose prds are already
- * TASKED (resolved against `work/prds/tasked/` residence, NOT `work/done/`).
+ * the spec's `taskedAfter` slugs, and the set of slugs whose prds are already
+ * TASKED (resolved against `work/specs/tasked/` residence, NOT `work/done/`).
  *
  * This mirrors the build-gate shape deliberately (CONTEXT.md / the `auto-slice`
- * prd): the same `needsAnswers !== true && humanOnly !== true && <repo policy>`
- * predicate, applied to a prd's two axes + the repo's `autoTask` toggle — and a
- * cross-prd ordering check that resolves against tasked-ness rather than done-ness.
+ * spec): the same `needsAnswers !== true && humanOnly !== true && <repo policy>`
+ * predicate, applied to a spec's two axes + the repo's `autoTask` toggle — and a
+ * cross-spec ordering check that resolves against tasked-ness rather than done-ness.
  */
 
 import type {HumanOnlyGate} from './eligibility.js';
 
 export type {HumanOnlyGate};
 
-/** Resolution of a prd's `taskedAfter` against the set of already-tasked prds. */
+/** Resolution of a spec's `taskedAfter` against the set of already-tasked prds. */
 export interface TaskedAfterResult {
-	/** True when every listed prd is already tasked. */
+	/** True when every listed spec is already tasked. */
 	satisfied: boolean;
-	/** Listed prd slugs not yet tasked, in declaration order. */
+	/** Listed spec slugs not yet tasked, in declaration order. */
 	missing: string[];
 }
 
 export interface TaskingEligibilityInput {
-	/** Autonomy axis 1 (DECIDED): a human must drive THIS prd's tasking. */
+	/** Autonomy axis 1 (DECIDED): a human must drive THIS spec's tasking. */
 	humanOnly: HumanOnlyGate;
-	/** Autonomy axis 2 (DISCOVERED): the prd has unresolved questions. */
+	/** Autonomy axis 2 (DISCOVERED): the spec has unresolved questions. */
 	needsAnswers: HumanOnlyGate;
-	/** Cross-prd order: prd slugs that must already be tasked before this one. */
+	/** Cross-spec order: spec slugs that must already be tasked before this one. */
 	taskedAfter: string[];
-	/** Slugs of prds that are already TASKED (residence in `work/prds/tasked/`). */
+	/** Slugs of prds that are already TASKED (residence in `work/specs/tasked/`). */
 	taskedSlugs: Set<string>;
 	/** Per-repo policy: may an agent auto-task *undeclared* prds in this repo? */
 	autoTask: boolean;
 	/**
-	 * The target was named EXPLICITLY by the operator (`do prd:<slug>`), so the
-	 * `autoTask` POLICY is already satisfied — naming the prd IS the authorization,
+	 * The target was named EXPLICITLY by the operator (`do spec:<slug>`), so the
+	 * `autoTask` POLICY is already satisfied — naming the spec IS the authorization,
 	 * exactly as `do <task>` builds a named task regardless of `autoBuild` (the
 	 * `autoBuild` precedent: the pool/scan gates the policy, the explicit claim path
 	 * never re-checks it). When `true`, the policy term drops from the gate and ONLY
-	 * the prd's own readiness axes (`humanOnly`/`needsAnswers`) + `taskedAfter` bind.
+	 * the spec's own readiness axes (`humanOnly`/`needsAnswers`) + `taskedAfter` bind.
 	 * Defaults `false` (the AUTO-PICK pool path, where the `autoTask` policy DOES
 	 * gate). The pool is the single policy-enforcement point; the per-invocation gate
 	 * applies the policy only when NOT explicit.
@@ -49,7 +49,7 @@ export interface TaskingEligibilityInput {
 }
 
 export interface TaskingEligibilityResult {
-	/** Taskable now = gate passes AND every `taskedAfter` prd is already tasked. */
+	/** Taskable now = gate passes AND every `taskedAfter` spec is already tasked. */
 	taskable: boolean;
 	/** Whether the autonomy gate alone passes (agent-taskable on its own axes). */
 	gatePass: boolean;
@@ -61,7 +61,7 @@ export interface TaskingEligibilityResult {
  * `true` AND `humanOnly` is not `true` AND the repo's `autoTask` POLICY is
  * satisfied — where the policy is satisfied either by the repo's `autoTask`
  * toggle being on (the AUTO-PICK pool path) OR by the target being named
- * EXPLICITLY (`explicit: true` — `do prd:<slug>`, where naming IS the
+ * EXPLICITLY (`explicit: true` — `do spec:<slug>`, where naming IS the
  * authorization, mirroring `do <task>` vs `autoBuild`). Both readiness axes
  * block orthogonally and are never agent-taskable regardless of policy; a human
  * is never bound by either. The exact mirror of `resolveGate` (the build gate),
@@ -82,9 +82,9 @@ export function resolveTaskGate(
 }
 
 /**
- * Resolve a prd's `taskedAfter` against the slugs of prds already TASKED (NOT
- * `done/`): satisfied iff every listed prd is present in `taskedSlugs`. An
- * untasked blocker ⇒ not yet taskable (so this prd's emitted tasks can
+ * Resolve a spec's `taskedAfter` against the slugs of prds already TASKED (NOT
+ * `done/`): satisfied iff every listed spec is present in `taskedSlugs`. An
+ * untasked blocker ⇒ not yet taskable (so this spec's emitted tasks can
  * reference the real slugs of those prds' tasks).
  */
 export function resolveTaskedAfter(

package/src/tasking-lock.ts

@@ -7,19 +7,19 @@ import {
 import {workItemRel} from './work-layout.js';
 
 /**
- * The **tasking concurrency lock** (prd `auto-slice`, task `autoslice-lock`).
+ * The **tasking concurrency lock** (spec `auto-slice`, task `autoslice-lock`).
  *
- * Serialises *concurrent* taskers (two CI runs, or human + CI) so a prd is never
+ * Serialises *concurrent* taskers (two CI runs, or human + CI) so a spec is never
  * double-tasked. As of the capstone cut-over (task
- * `cutover-retire-slicing-advancing-markers-and-trim-folder-sets`, prd
+ * `cutover-retire-slicing-advancing-markers-and-trim-folder-sets`, spec
  * `ledger-status-per-item-lock-refs`; ADR `ledger-status-on-per-item-lock-refs`)
- * the legacy `git mv work/prds/ready/<slug>.md → work/tasking/<slug>.md` MARKER on `main`
+ * the legacy `git mv work/specs/ready/<slug>.md → work/tasking/<slug>.md` MARKER on `main`
  * is GONE: the body NEVER relocates until the durable promotion, exactly as claim
  * no longer moves the task body (task
  * `cutover-claim-body-stays-and-complete-sources-from-backlog`). The tasking lock
  * is now ONLY the UNIFIED per-item lock (`refs/dorfl/lock/<entry>`,
- * `action: task`, keyed `prd:<slug>`) — the SAME ref claim and advance use for
- * the same item, so tasking a prd is mutually exclusive with claiming/advancing
+ * `action: task`, keyed `spec:<slug>`) — the SAME ref claim and advance use for
+ * the same item, so tasking a spec is mutually exclusive with claiming/advancing
  * the SAME item BY CONSTRUCTION (the second acquirer loses the SAME create-only
  * ref CAS, with NO retry budget and NO false contention). There is no transient
  * status in `main`'s tree anymore, so a work branch cut from `main` inherits no
@@ -29,9 +29,9 @@ import {workItemRel} from './work-layout.js';
  *   A `lost` (the item is already held for implement/task/advance) makes the
  *   tasking acquire lose DEFINITIVELY (exit 2, no retry). On a successful acquire
  *   it returns {@link AcquireTaskingLockResult.lockedBlob}: the git blob sha of the
- *   prd body the lock TOOK, read from `work/prds/ready/<slug>.md` on the arbiter — the
+ *   spec body the lock TOOK, read from `work/specs/ready/<slug>.md` on the arbiter — the
  *   snapshot the tasker reads + tasks from, handed back so the integrate
- *   transition can fail loud if the held prd was edited concurrently (the
+ *   transition can fail loud if the held spec was edited concurrently (the
  *   read-stability backstop). A dry-run takes no lock (it mutates nothing).
  *
  * - **Release** ({@link releaseTaskingLock}) DELETES the unified lock ref. It
@@ -51,11 +51,11 @@ import {workItemRel} from './work-layout.js';
  * The READ-STABILITY backstop (the content-identity stale check that used to live
  * in the release, comparing the held `work/tasking/<slug>.md` blob against the
  * acquire-time snapshot) now lives at the integrate seam (`tasking.ts`
- * `heldSpecIsStale`, comparing `work/prds/ready/<slug>.md`) — relocated because the
+ * `heldSpecIsStale`, comparing `work/specs/ready/<slug>.md`) — relocated because the
  * completing transition, not the release, owns the commit. See
  * `work/notes/observations/tasking-lock-does-not-stabilise-prd-content.md`.
  *
- * This module provides the lock PRIMITIVES only. The orchestrating `do prd:<slug>`
+ * This module provides the lock PRIMITIVES only. The orchestrating `do spec:<slug>`
  * tasking command (`tasking.ts`) acquires, drives the agent's tasking, integrates
  * the emitted tasks + the durable `prd → prd-tasked` move, and releases. The
  * human path (no contention) may task on `main` directly without the lock.
@@ -74,7 +74,7 @@ export type AcquireTaskingLockOutcome =
 export type AcquireTaskingLockExitCode = 0 | 1 | 2 | 3;
 
 export interface AcquireTaskingLockOptions {
-	/** The prd slug to lock (`work/prds/ready/<slug>.md`). */
+	/** The spec slug to lock (`work/specs/ready/<slug>.md`). */
 	slug: string;
 	/** Working clone/worktree the lock acquire runs in. */
 	cwd: string;
@@ -98,10 +98,10 @@ export interface AcquireTaskingLockResult {
 	/** Human-readable summary of the terminal condition. */
 	message: string;
 	/**
-	 * On a successful acquire (`acquired`), the git BLOB sha of the prd body that
-	 * the lock TOOK (`work/prds/ready/<slug>.md` on the arbiter). This IS the snapshot the
+	 * On a successful acquire (`acquired`), the git BLOB sha of the spec body that
+	 * the lock TOOK (`work/specs/ready/<slug>.md` on the arbiter). This IS the snapshot the
 	 * tasker reads + tasks from; the integrate transition compares the current
-	 * `work/prds/ready/<slug>.md` blob against it to fail loud on a concurrent edit (the
+	 * `work/specs/ready/<slug>.md` blob against it to fail loud on a concurrent edit (the
 	 * read-stability backstop). `undefined` unless `outcome === 'acquired'` (and on
 	 * dry-run, where nothing was published).
 	 */
@@ -157,7 +157,7 @@ async function runAcquire(
 	}
 	const by = options.by || (await resolveBy(cwd, env));
 
-	// Is the prd still lockable (present in work/prds/ready/ on the arbiter's main)?
+	// Is the spec still lockable (present in work/specs/ready/ on the arbiter's main)?
 	await gitHard(['fetch', '--quiet', arbiter], cwd, env);
 	const spec = workItemRel('specs-ready', `${slug}.md`);
 	const specBlob = await gitSoft(
@@ -166,7 +166,7 @@ async function runAcquire(
 		env,
 	);
 	if (specBlob.status !== 0) {
-		const message = `'${spec}' not found on ${arbiter}/main (no such prd, or it was already moved/tasked).`;
+		const message = `'${spec}' not found on ${arbiter}/main (no such spec, or it was already moved/tasked).`;
 		note(message);
 		return {exitCode: 2, outcome: 'lost', message};
 	}
@@ -180,18 +180,17 @@ async function runAcquire(
 		return {exitCode: 0, outcome: 'acquired', message, lockedBlob};
 	}
 
-	// Acquire the UNIFIED per-item lock (`action: task`, keyed `prd:<slug>` so it
+	// Acquire the UNIFIED per-item lock (`action: task`, keyed `spec:<slug>` so it
 	// shares the ONE ref with claim/advance of the SAME item). A create-only ref
 	// CAS: the winner holds it, the loser is DEFINITIVELY `lost` (exit 2, no retry
 	// budget). No auto-steal of an orphaned lock, consistent with claim/advance and
 	// the ADR's recovery model (no liveness heartbeat / auto-sweep; a human asserts
 	// a lock is dead via `release-lock` + `gc --ledger`).
-	// MIGRATE step (prd `prd-to-spec-vocabulary-cutover-and-migration-command`):
-	// EMIT the parent-spec item identity as `spec:<slug>` so the unified per-item
-	// lock ref is `refs/dorfl/lock/spec-<slug>` (the expand-lock task made
-	// `spec:<slug>` resolve to a `spec-<slug>` entry). The resolver still ACCEPTS
-	// `prd:<slug>`, so any lock taken under the old identity stays readable; the
-	// contract task removes the legacy form.
+	// Spec `prd-to-spec-vocabulary-cutover-and-migration-command`: the parent-spec
+	// item identity is `spec:<slug>`, so the unified per-item lock ref is
+	// `refs/dorfl/lock/spec-<slug>`. HARD CUTOVER: the legacy `prd:<slug>` identity
+	// is GONE — the resolver no longer treats `prd:` as the spec namespace (a
+	// `prd:<slug>` arg is a bare literal task slug now).
 	const lock = await acquireItemLock({
 		item: `spec:${slug}`,
 		action: 'task',
@@ -228,7 +227,7 @@ export type ReleaseTaskingLockOutcome =
 export type ReleaseTaskingLockExitCode = 0 | 1 | 2 | 3 | 4;
 
 export interface ReleaseTaskingLockOptions {
-	/** The prd slug whose lock to release. */
+	/** The spec slug whose lock to release. */
 	slug: string;
 	/** Working clone/worktree the release runs in. */
 	cwd: string;
@@ -249,9 +248,9 @@ export interface ReleaseTaskingLockOptions {
 	/**
 	 * The tasker review→edit LOOP's **decomposition-unclear** verdict
 	 * (`slicer-review-edit-loop`), or the task-SET acceptance gate's `block`:
-	 * instead of DELETING the lock (returning the prd to the claimable/taskable
+	 * instead of DELETING the lock (returning the spec to the claimable/taskable
 	 * pool), amend it `active → stuck` with this reason recorded on the entry,
-	 * emitting NO guessed tasks. The prd body stays in `work/prds/ready/` (it never moved
+	 * emitting NO guessed tasks. The spec body stays in `work/specs/ready/` (it never moved
 	 * under the lock); the stuck lock IS the tasking needs-attention surface (no
 	 * `work/needs-attention/` folder write), so it is NOT re-taskable until a human
 	 * resolves it via `release-lock`/`resume`. Omitted ⇒ the normal release DELETES
@@ -275,7 +274,7 @@ export interface ReleaseTaskingLockResult {
  * Release the tasking lock for `slug`: DELETE the unified `action: task` lock ref
  * (idempotent — an already-absent ref is a clean `released`). It moves NO lifecycle
  * file: the durable `prd → prd-tasked` success move is owned by the integrate band,
- * and the prd body never left `work/prds/ready/` under the lock, so there is no
+ * and the spec body never left `work/specs/ready/` under the lock, so there is no
  * `tasking/ → prd/` restore.
  *
  * When `routeToNeedsAttention` is set (the tasker decomposition-unclear verdict /
@@ -328,7 +327,7 @@ async function runRelease(
 
 	// DECOMPOSITION-UNCLEAR / TASK-GATE BLOCK: amend the lock `active → stuck` with
 	// the reason on the entry (the tasking needs-attention surface), NOT delete it.
-	// The prd body stays in `work/prds/ready/`; the stuck lock keeps it out of the
+	// The spec body stays in `work/specs/ready/`; the stuck lock keeps it out of the
 	// taskable pool until a human resolves it (`release-lock`/`resume`).
 	if (options.routeToNeedsAttention !== undefined) {
 		// MIGRATE: EMIT `spec:<slug>` (keyed to the `spec-<slug>` lock entry).