thoth-agents 0.2.11 → 0.3.1

package/skills/thoth-constitution/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: thoth-constitution
+description: Create or explicitly amend the project constitution, choose its governance SemVer bump, propagate its impact, and validate lifecycle metadata. Use only for constitution lifecycle work; routine SDD planning reads the constitution without activating this skill.
+---
+
+# Thoth Constitution
+
+The canonical project constitution is `openspec/memory/constitution.md`.
+
+## Routine SDD
+
+- Read every active principle before planning.
+- Record concrete pre-design and post-design Constitution Check evidence in
+  `plan.md`.
+- Do not amend the constitution, bump its version, or run lifecycle validation
+  for an ordinary feature change.
+
+## Explicit amendment
+
+Activate this lifecycle only on explicit user direction or when the user accepts
+a confirmed durable governance change.
+
+1. Read the current constitution and every affected template, instruction, and
+   durable workflow document.
+2. Classify the governance version bump:
+   - **MAJOR** removes or redefines a principle or compatibility boundary.
+   - **MINOR** adds a principle/section or materially expands guidance.
+   - **PATCH** clarifies wording without semantic change.
+3. Preserve the original ratification date, set `Last amended` to today, and
+   update `Version` using complete `MAJOR.MINOR.PATCH` SemVer.
+4. Prepend or refresh the HTML-comment `Sync Impact Report`: old → new version,
+   modified principles, added/removed sections, affected templates with status,
+   and follow-up TODOs.
+5. Propagate the accepted rule to every affected template, instruction, and
+   documentation surface in the same change.
+6. Remove unexplained placeholders and deferred TODOs, then run:
+
+```bash
+node skills/thoth-constitution/scripts/validate.mjs \
+  --constitution openspec/memory/constitution.md --json
+```
+
+Initialization copies `templates/constitution.md` only when the project has no
+constitution, resolves its date placeholders, and never overwrites a
+project-owned constitution.

package/skills/thoth-constitution/scripts/validate.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+function parseArgs(argv) {
+  const options = { json: false };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--json') options.json = true;
+    else if (argument === '--constitution') {
+      options.constitution = argv[++index];
+    } else {
+      throw new Error(`Unknown argument: ${argument}`);
+    }
+  }
+  if (!options.constitution) throw new Error('--constitution is required');
+  return options;
+}
+
+function issue(code, message) {
+  return { code, message };
+}
+
+function metadata(content, name) {
+  return new RegExp(`^\\*\\*${name}\\*\\*:\\s*([^<\\n]+)`, 'im')
+    .exec(content)?.[1]
+    .trim();
+}
+
+function isIsoDate(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value ?? '')) return false;
+  const date = new Date(`${value}T00:00:00.000Z`);
+  return (
+    !Number.isNaN(date.valueOf()) && date.toISOString().slice(0, 10) === value
+  );
+}
+
+function validate(content) {
+  const errors = [];
+  if (
+    /\bYYYY-MM-DD\b|\[[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+\]|TODO\([A-Z0-9_]+\)/.test(
+      content,
+    )
+  ) {
+    errors.push(
+      issue(
+        'CONSTITUTION-PLACEHOLDER',
+        'Resolve every template placeholder and deferred TODO before adoption.',
+      ),
+    );
+  }
+
+  const version = metadata(content, 'Version');
+  if (!/^\d+\.\d+\.\d+$/.test(version ?? '')) {
+    errors.push(
+      issue(
+        'CONSTITUTION-VERSION',
+        'Version must be a complete MAJOR.MINOR.PATCH value.',
+      ),
+    );
+  }
+
+  const ratified = metadata(content, 'Ratified');
+  const lastAmended = metadata(content, 'Last amended');
+  if (!isIsoDate(ratified) || !isIsoDate(lastAmended)) {
+    errors.push(
+      issue(
+        'CONSTITUTION-DATE',
+        'Ratified and Last amended must be real ISO dates in YYYY-MM-DD format.',
+      ),
+    );
+  } else if (lastAmended < ratified) {
+    errors.push(
+      issue(
+        'CONSTITUTION-DATE-ORDER',
+        'Last amended cannot precede the ratification date.',
+      ),
+    );
+  }
+
+  const report = /^\s*<!--([\s\S]*?)-->/.exec(content)?.[1];
+  const requiredImpactFields = [
+    'Version change',
+    'Modified principles',
+    'Added sections',
+    'Removed sections',
+    'Templates',
+    'Follow-up TODOs',
+  ];
+  if (
+    !report?.includes('Sync Impact Report') ||
+    requiredImpactFields.some(
+      (field) => !new RegExp(`^- ${field}:\\s*\\S`, 'im').test(report),
+    )
+  ) {
+    errors.push(
+      issue(
+        'CONSTITUTION-SYNC-IMPACT',
+        'Prepend a complete Sync Impact Report describing the amendment propagation.',
+      ),
+    );
+  }
+  if (
+    version &&
+    report &&
+    !new RegExp(
+      `^- Version change:\\s*.+?(?:->|→)\\s*${version.replaceAll('.', '\\.')}(?:\\s|$)`,
+      'im',
+    ).test(report)
+  ) {
+    errors.push(
+      issue(
+        'CONSTITUTION-SYNC-VERSION',
+        'The Sync Impact Report version transition must end at the adopted version.',
+      ),
+    );
+  }
+
+  const governance = /^##\s+Governance\s*$([\s\S]*)/im.exec(content)?.[1];
+  if (
+    !governance ||
+    !['MAJOR', 'MINOR', 'PATCH'].every((term) =>
+      new RegExp(`\\b${term}\\b`).test(governance),
+    )
+  ) {
+    errors.push(
+      issue(
+        'CONSTITUTION-SEMVER-POLICY',
+        'Governance must define explicit MAJOR, MINOR, and PATCH amendment semantics.',
+      ),
+    );
+  }
+
+  if (!/^##\s+(?:Core )?Principles\s*$/im.test(content)) {
+    errors.push(
+      issue(
+        'CONSTITUTION-PRINCIPLES',
+        'Define an explicit Principles section with active project rules.',
+      ),
+    );
+  }
+
+  return { valid: errors.length === 0, version, errors };
+}
+
+try {
+  const options = parseArgs(process.argv.slice(2));
+  const path = resolve(options.constitution);
+  if (!existsSync(path)) throw new Error(`Constitution not found: ${path}`);
+  const result = validate(readFileSync(path, 'utf8'));
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+  } else if (result.valid) {
+    process.stdout.write(`Constitution ${result.version} is valid.\n`);
+  } else {
+    process.stderr.write(
+      `${result.errors.map((error) => `${error.code}: ${error.message}`).join('\n')}\n`,
+    );
+  }
+  if (!result.valid) process.exitCode = 1;
+} catch (error) {
+  process.stderr.write(
+    `${error instanceof Error ? error.message : String(error)}\n`,
+  );
+  process.exitCode = 2;
+}

package/skills/thoth-constitution/templates/constitution.md

@@ -0,0 +1,54 @@
+<!--
+Sync Impact Report
+- Version change: N/A -> 1.0.0
+- Modified principles: None (initial ratification)
+- Added sections: Principles; Governance
+- Removed sections: None
+- Templates: ✅ initialized by thoth-init
+- Follow-up TODOs: None
+-->
+# Project Constitution
+
+**Version**: 1.0.0<br>
+**Ratified**: YYYY-MM-DD<br>
+**Last amended**: YYYY-MM-DD
+
+## Principles
+
+### I. User-value first
+
+Every change MUST map to an observable user or operator outcome. Speculative
+infrastructure without a current requirement is prohibited.
+
+### II. Simplicity and bounded scope
+
+Delivery MUST use the smallest coherent design that satisfies accepted
+requirements. Non-goals MUST be named, and scope cannot expand silently.
+
+### III. Testable contracts
+
+Behavioral requirements MUST have observable acceptance evidence. Behavior
+changes MUST use test-first execution at an agreed public seam when practical.
+
+### IV. Independent assurance
+
+The implementation writer cannot approve its own work. Analyze and verify MUST
+be performed by an independent read-only reviewer.
+
+### V. Traceable delivery
+
+Specifications, plans, tasks, implementation evidence, verification verdicts,
+and archive reports MUST remain traceable without relying on chat history.
+
+## Governance
+
+- Planning MUST record evidence-backed Constitution Check results before and
+  after design; routine feature work reads the principles but does not amend or
+  revalidate constitution lifecycle metadata.
+- Exceptions MUST identify the principle, reason, risk, owner, and removal
+  condition.
+- Amendments require explicit user direction, an updated Sync Impact Report,
+  and propagation to affected templates, instructions, and documentation.
+- MAJOR versions remove or redefine governance compatibility.
+- MINOR versions add a principle or materially expand guidance.
+- PATCH versions clarify wording without changing its meaning.

package/skills/thoth-init/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: thoth-init
+description: Initialize project SDD governance and OpenCode local skills from the installed bundle; Codex global agents and instructions remain CLI-owned.
+---
+
+# Thoth Init
+
+Initialize the current project from this installed skill bundle. Resolve
+`<skill-dir>` as the directory containing this `SKILL.md`, then run the bundled
+script by absolute path:
+
+```text
+node "<skill-dir>/scripts/init.mjs" --project <project-root> --harness <opencode|codex|claude> --json
+```
+
+- OpenCode materializes the four thoth-owned workflow skills under
+  `.agents/skills/`.
+- Codex init creates project governance only. Codex plugin manifests cannot
+  install custom agents or global instructions; first run the mandatory
+  thoth-agents CLI setup that manages `~/.codex/agents/`,
+  `~/.codex/AGENTS.md`, and `~/.codex/config.toml`.
+- Claude uses auto-discovered plugin agents and owned skills; init creates only
+  project governance assets.
+
+For every harness, installation must already have used the thoth-agents CLI to
+install mandatory external skills from their canonical repositories. This init
+skill never invokes the CLI or downloads a skill.
+
+The operation is offline and idempotent. It never overwrites the project
+constitution, templates, or unrelated instruction content.

package/skills/thoth-init/scripts/init.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_PATH = fileURLToPath(import.meta.url);
+const SKILL_ROOT = dirname(dirname(SCRIPT_PATH));
+const BUNDLE_ROOT = dirname(SKILL_ROOT);
+const OWNED_SKILL_NAMES = [
+  'thoth-init',
+  'thoth-sdd',
+  'thoth-constitution',
+  'thoth-archive',
+];
+
+function parseArgs(argv) {
+  const options = { json: false };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--json') options.json = true;
+    else if (argument === '--project') options.project = argv[++index];
+    else if (argument === '--harness') options.harness = argv[++index];
+    else throw new Error(`Unknown argument: ${argument}`);
+  }
+  if (!options.project) throw new Error('--project is required');
+  if (!['opencode', 'codex', 'claude'].includes(options.harness)) {
+    throw new Error('--harness must be opencode, codex, or claude');
+  }
+  return options;
+}
+
+function copyMissing(source, target, report) {
+  if (!existsSync(source)) return;
+  const sourceStat = statSync(source);
+  if (sourceStat.isDirectory()) {
+    mkdirSync(target, { recursive: true });
+    for (const entry of readdirSync(source)) {
+      copyMissing(join(source, entry), join(target, entry), report);
+    }
+    return;
+  }
+  if (existsSync(target)) {
+    report.skipped.push(target);
+    return;
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  cpSync(source, target, { errorOnExist: true });
+  report.created.push(target);
+}
+
+function writeMissing(target, content, report) {
+  if (existsSync(target)) {
+    report.skipped.push(target);
+    return;
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, content);
+  report.created.push(target);
+}
+
+function installConstitution(project, report) {
+  const target = join(project, 'openspec', 'memory', 'constitution.md');
+  const template = join(
+    BUNDLE_ROOT,
+    'thoth-constitution',
+    'templates',
+    'constitution.md',
+  );
+  if (!existsSync(template)) return;
+  const today = new Date().toISOString().slice(0, 10);
+  writeMissing(
+    target,
+    readFileSync(template, 'utf8').replaceAll('YYYY-MM-DD', today),
+    report,
+  );
+}
+
+function installGovernance(project, report) {
+  installConstitution(project, report);
+  const templatesRoot = join(BUNDLE_ROOT, 'thoth-sdd', 'templates');
+  if (existsSync(templatesRoot)) {
+    for (const entry of readdirSync(templatesRoot)) {
+      copyMissing(
+        join(templatesRoot, entry),
+        join(project, 'openspec', 'templates', entry),
+        report,
+      );
+    }
+  }
+  writeMissing(
+    join(project, 'openspec', '.thoth-agents.json'),
+    `${JSON.stringify({ version: 1, initializedBy: 'thoth-agents' }, null, 2)}\n`,
+    report,
+  );
+}
+
+function installOpenCode(project, report) {
+  for (const skillName of OWNED_SKILL_NAMES) {
+    copyMissing(
+      join(BUNDLE_ROOT, skillName),
+      join(project, '.agents', 'skills', skillName),
+      report,
+    );
+  }
+}
+
+try {
+  const options = parseArgs(process.argv.slice(2));
+  const project = resolve(options.project);
+  mkdirSync(project, { recursive: true });
+  const report = {
+    status: 'ready',
+    harness: options.harness,
+    project,
+    created: [],
+    managed: [],
+    skipped: [],
+  };
+
+  installGovernance(project, report);
+  if (options.harness === 'opencode') installOpenCode(project, report);
+
+  const output = options.json
+    ? JSON.stringify(report)
+    : `thoth-agents initialized ${project} for ${options.harness}`;
+  process.stdout.write(`${output}\n`);
+} catch (error) {
+  process.stderr.write(
+    `${error instanceof Error ? error.message : String(error)}\n`,
+  );
+  process.exitCode = 1;
+}

package/skills/thoth-sdd/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: thoth-sdd
+description: Run thoth-agents Direct, Accelerated, or Full specification-driven development with Spec Kit-grade artifacts, OpenSpec-style durable deltas, fast-forward planning, and oracle-only analysis and verification.
+---
+
+# Thoth SDD
+
+Select the lightest route that preserves correctness:
+
+- **Direct**: `implement -> verify`
+- **Accelerated**: `specify -> plan -> tasks -> implement -> verify -> archive`
+- **Full**: `explore -> specify -> plan -> tasks -> analyze -> implement -> verify -> archive`
+
+Conditional phases are `clarify`, `checklist`, and `converge`. Direct creates no
+SDD artifacts and may cover multiple documentation or mechanical files when the
+intent is clear and risk is low.
+
+Accelerated is a **fast-forward** route: root writes `spec.md`, `plan.md`, and
+`tasks.md` in one uninterrupted pass, validates structure without a routine user
+pause, and creates optional artifacts only for a concrete risk. Full uses
+phase-by-phase gates because uncertainty or failure cost justifies them.
+
+An explicitly named route wins. A generic request to “use SDD” sets Accelerated
+as the minimum; it does not force Full. User input is requested only for a
+material decision that evidence and safe assumptions cannot resolve.
+
+## Ownership
+
+- Root owns sequential coordination artifacts, gate execution, and archive.
+- Explorer owns Full-route repository discovery.
+- Designer, quick, deep, or root may implement according to scope.
+- Oracle always owns `analyze` and **every** `verify`. The implementation writer
+  never approves its own work.
+
+## Progressive loading
+
+Use only installed local contracts during the pipeline. Never invoke the
+thoth-agents CLI, `npx skills add`, or a network fetch to advance an SDD phase.
+If a required contract or external skill is missing, stop and report an
+incomplete installation instead of provisioning it mid-workflow.
+
+Read only the current phase contract:
+
+| Phase | Contract |
+| --- | --- |
+| explore | `references/phases/explore.md` |
+| specify | `references/phases/specify.md` |
+| clarify | `references/phases/clarify.md` |
+| plan | `references/phases/plan.md` |
+| checklist | `references/phases/checklist.md` |
+| tasks | `references/phases/tasks.md` |
+| analyze | `references/phases/analyze.md` |
+| implement | `references/phases/implement.md` |
+| verify | `references/phases/verify.md` |
+| converge | `references/phases/converge.md` |
+| archive | bundled `thoth-archive` skill |
+
+## Validation gates
+
+Run the validator from this skill directory:
+
+```text
+node scripts/validate.mjs --change openspec/changes/<feature> --route <accelerated|full> --through <specify|plan|tasks|checklist|ready|closeout> --json
+```
+
+- **Accelerated**: `specify`, then `ready` after the fast-forward planning pass,
+  then `closeout` after independent verification and an archive report marked
+  `READY`.
+- **Full**: `specify`, `plan`, `tasks`, then `ready` before oracle analysis, and
+  `closeout` after independent verification.
+- **Checklist**: run only when activated; the later `ready` gate includes it if
+  present.
+
+`ready` validates the artifacts needed before analysis/implementation.
+`closeout` additionally requires completed tasks, independent oracle PASS,
+complete FR/buildable-SC evidence, an observed PASS or explicit residual RISK
+for every outcome SC, and an archive report ready for the transactional archive
+transition.
+
+When implementation evidence refines the same intent, root updates the canonical
+artifact and revalidates only affected downstream artifacts/gates. A changed
+intent starts a new change. Structural validation prevents malformed artifacts;
+oracle still judges completeness, correctness, coherence, and evidence.

package/skills/thoth-sdd/references/phases/analyze.md

@@ -0,0 +1,21 @@
+# Analyze contract
+
+**Owner**: oracle (read-only, independent)<br>
+**Applies to**: Full
+
+Review `spec.md`, `plan.md`, `tasks.md`, the constitution, and any activated
+checklist across three separate dimensions:
+
+- **Completeness**: all accepted scope, FRs, buildable SCs, stories, failures,
+  and constraints have downstream coverage.
+- **Correctness**: requirements and technical choices are testable, feasible,
+  and consistent with repository evidence and the constitution.
+- **Coherence**: spec, plan, tasks, dependencies, and verification seams do not
+  contradict or duplicate one another.
+
+Buildable SCs require tasks; outcome SCs require measurable validation intent,
+not fake implementation tasks. Report stable finding IDs with
+CRITICAL/HIGH/MEDIUM/LOW severity, coverage percentages, checklist status, and a
+`ready` or `blocked` verdict. Any CRITICAL finding, constitution violation, or
+FR/buildable SC with zero task coverage blocks implementation. Never edit
+artifacts; root owns remediation.

package/skills/thoth-sdd/references/phases/checklist.md

@@ -0,0 +1,20 @@
+# Checklist contract
+
+**Owner**: root<br>
+**Output**: `checklists/requirements.md`<br>
+**Activation**: high contract/failure risk, compliance sensitivity, or
+ambiguity-prone scope
+
+Record the concrete activation reason. Use sequential `CHK###` items to audit
+the requirements—not implementation—across the base taxonomy: Completeness,
+Clarity, Consistency, Measurability, and Coverage.
+
+Add only applicable domain lenses, such as security, privacy, accessibility,
+compliance, performance, migration, or domain-specific failure rules. If none
+apply, record an evidence-backed `None` decision instead of boilerplate checks.
+Map every US, FR, SC, actor, failure mode, and relevant constraint to evidence.
+
+After clarification or planning changes, check affected revalidation items. If
+no requirement-affecting artifact changed, record an evidence-backed `Not
+required` no-op. Unresolved high-risk gaps return to specify; checklist status
+must never be inferred from code tests.

package/skills/thoth-sdd/references/phases/clarify.md

@@ -0,0 +1,15 @@
+# Clarify contract
+
+**Owner**: root<br>
+**Activation**: material ambiguity only
+
+Classify requirement dimensions as **Clear**, **Partial**, or **Missing** across
+scope, actors, data, interactions, non-functional constraints, failure behavior,
+and success evidence. Resolve from repository evidence or a safe documented
+assumption first. Ask one targeted human question only when the answer materially
+changes the result; Full SDD should normally ask no more than five high-impact
+questions in one clarification pass.
+
+Write every accepted answer directly into `spec.md`, cite the changed FR/SC/story,
+then re-run structural validation and revalidate any existing requirements
+checklist. Do not create a parallel clarification document.

package/skills/thoth-sdd/references/phases/converge.md

@@ -0,0 +1,14 @@
+# Converge contract
+
+**Owner**: root<br>
+**Activation**: failed artifact-backed verification
+
+Classify every oracle gap as `missing`, `partial`, `contradicts`, or
+`unrequested`. Append one traceable remediation task per actionable gap to a new
+Convergence section in `tasks.md`, ordered by severity and linked to its finding,
+FR/buildable SC, exact writer surface, and verification outcome.
+
+Never rewrite, renumber, reorder, or delete earlier tasks, and never edit product
+code during convergence. If no actionable gap exists, leave `tasks.md`
+byte-for-byte unchanged. Return to implement, then always ask oracle to verify
+again.

package/skills/thoth-sdd/references/phases/explore.md

@@ -0,0 +1,10 @@
+# Explore contract
+
+**Owner**: explorer (read-only)<br>
+**Applies to**: Full
+
+Resolve only repository uncertainty that affects requirements or design. Inspect
+the smallest useful anchors and return relevant paths/symbols, confirmed current
+behavior, constraints, safe assumptions, unresolved human-owned decisions, and
+recommended specification anchors. Do not write files or return raw logs. Stop
+when root can specify without repeating discovery.

package/skills/thoth-sdd/references/phases/implement.md

@@ -0,0 +1,19 @@
+# Implement contract
+
+**Owner**: root, designer, quick, or deep; exactly one writer per mutable surface
+
+Root marks selected artifact-backed tasks `[~]`, then assigns exact paths,
+accepted FR/buildable-SC scope, non-goals, and verification commands. Use the
+mandatory `tdd` skill for behavior changes and work in vertical red/green
+slices. Child writers never edit task state; root marks `[x]` only after checking
+task-specific evidence.
+
+Implementation evidence may refine an artifact without restarting the workflow:
+
+- If it preserves the accepted intent, return the evidence to root; root updates
+  the canonical artifact and revalidates only affected downstream artifacts and
+  gates.
+- If it changes intent or accepted product scope, start a new change rather than
+  silently expanding this one.
+
+Report files changed, checks executed, deviations, and remaining work.

package/skills/thoth-sdd/references/phases/plan.md

@@ -0,0 +1,15 @@
+# Plan contract
+
+**Owner**: root<br>
+**Output**: `openspec/changes/<feature>/plan.md`
+
+Start from `templates/plan.md`. Read active constitution principles and record
+evidence-backed pre-design and post-design Constitution Checks. Routine SDD does
+not amend the constitution or run its lifecycle validator; activate
+`thoth-constitution` only when an explicit constitution amendment is in scope.
+
+Map each technical choice to FR/SC or a confirmed repository constraint. Name
+affected components, interfaces, exact paths, migrations, risks, rollback, and
+verification seams. Create `research.md`, `data-model.md`, `contracts/`, or
+`quickstart.md` only when that artifact resolves a concrete implementation risk.
+Any unexplained constitution failure blocks tasks.

package/skills/thoth-sdd/references/phases/specify.md

@@ -0,0 +1,21 @@
+# Specify contract
+
+**Owner**: root<br>
+**Output**: `openspec/changes/<feature>/spec.md`
+
+Start from `templates/spec.md` and remain implementation-neutral.
+
+- Record **Why**, **Impact**, and affected kebab-case capability slugs (or
+  `None`).
+- Define prioritized, independently testable `US#` stories. Every story needs
+  `Covers: FR-###, SC-###` and Given/When/Then acceptance scenarios.
+- Give every sequential FR a descriptive title, a normative `MUST`/`SHALL`
+  statement, and exactly one delta marker: `INTERNAL`, `ADDED`, `MODIFIED`,
+  `REMOVED`, or `RENAMED ... FROM ...`.
+- Type each measurable SC as `buildable` or `outcome`. Buildable criteria require
+  implementation coverage; outcome criteria remain product/operational
+  verification targets without fake tasks.
+- State assumptions, dependencies, edge cases, and explicit non-goals.
+
+Do not advance while a material ambiguity would change scope, behavior,
+architecture, or durable delta intent.