aimship 0.1.0-preview.11 → 0.1.0-preview.13

package/lib/approvals.mjs

@@ -1,12 +1,11 @@
 import { isDeepStrictEqual } from 'node:util';
-import { artifactMap, safeRead, anchors } from './documents.mjs';
+import { artifactMap, safeRead, hasLocator, sections } from './documents.mjs';
 import { fail, hash } from './io.mjs';
 
 const text = value => typeof value === 'string' && value.trim().length > 0;
 const reject = message => fail('REVIEW_CHECK', message, 'Read review status. Preserve history, self-check the current document, and record only an actual explicit user decision.');
 const kinds = ['self-check', 'approved', 'changes-requested', 'editorial'];
 export function validateReviewState(state) {
-  if (state.reviewPolicy === undefined) return;
   if (state.reviewPolicy !== 1 || !Array.isArray(state.reviewHistory)) reject('Unsupported review policy or missing reviewHistory.');
   const ids = new Set();
   for (const r of state.reviewHistory) {
@@ -27,8 +26,9 @@ export async function reviewFingerprint(directory, state, doc) {
   let body = await safeRead(directory, state, doc.path, stop ? 'utf8' : null);
   if (body === null) return null;
   if (stop) {
-    const at = body.search(new RegExp(`<a\\s+id=["']${stop}["']\\s*><\\/a>`));
-    if (at < 0) return null;
+    const boundary=sections(body,(await artifactMap()).documents[doc.kind]).find(s=>s.id===stop);
+    if(boundary?.count!==1) return null;
+    const at=boundary.start;
     body = body.slice(0, at);
   }
   const assets = [];
@@ -49,8 +49,50 @@ function decisionFor(state, doc, digest) {
   if (approved?.version !== doc.version || approved?.digest !== digest) approved = null;
   return { approved, checked, latest };
 }
+// A corrective review may consume a failed conclusion without first pretending
+// it passed. Its recorded coverage must include the object it supersedes.
+function reviewsResult(later, earlier) {
+  return later.stage === 'review' && earlier.stage === 'review' && text(earlier.resultRef)
+    && later.historyResultRefs?.includes(earlier.resultRef)
+    && (!earlier.overall || later.overall === true)
+    && (earlier.reviewOf?.length
+      ? earlier.reviewOf.every(id => later.reviewOf?.includes(id))
+      : !later.reviewOf?.length && later.scope === earlier.scope);
+}
+// Required edges for standard delivery are derived from the actual work, not
+// optional inputRefs/dependsOn. Limited commissions retain their selected graph.
+function standardEntry(state, run, index, completed) {
+  const before=state.stageRuns.slice(0,index), dependsOn=[], issues=[];
+  const status=id=>completed.find(r=>r.id===id);
+  const implementations=before.filter(r=>r.stage==='implement');
+  if(run.stage==='review') {
+    const covered=run.reviewOf??[];
+    if(!covered.length) issues.push('entry:implementation-coverage');
+    dependsOn.push(...covered);
+    if(run.overall && implementations.some(r=>!covered.includes(r.id))) issues.push('entry:overall-coverage');
+    for(const id of covered) {
+      const implementation=state.stageRuns.find(r=>r.id===id);
+      if(['failed','mixed','unknown','not-run'].includes(implementation?.result)) issues.push(`entry:implementation-result:${id}`);
+    }
+  } else if(['verify','handoff'].includes(run.stage)) {
+    if(!implementations.length) issues.push('entry:implementation');
+    dependsOn.push(...implementations.map(r=>r.id),...before.filter(r=>r.stage==='review').map(r=>r.id));
+    const overall=before.findLast(r=>r.stage==='review' && r.overall && r.result==='passed' && status(r.id)?.releaseReady && implementations.length && implementations.every(b=>r.reviewOf?.includes(b.id) && before.indexOf(b)<before.indexOf(r)));
+    if(!overall) issues.push('entry:passing-overall-review');
+    if(run.stage==='handoff') {
+      const checks=before.filter(r=>r.stage==='verify');
+      const effective=checks.filter((r,i)=>!checks.slice(i+1).some(later=>status(later.id)?.releaseReady && later.result==='passed' && later.historyResultRefs?.includes(r.resultRef)));
+      if(!effective.length) issues.push('entry:verification');
+      dependsOn.push(...checks.map(r=>r.id));
+      for(const check of effective) {
+        if(check.result!=='passed') issues.push(`entry:verification-result:${check.id}`);
+        if(overall && before.indexOf(check)<before.indexOf(overall)) issues.push(`entry:verification-before-review:${check.id}`);
+      }
+    }
+  }
+  return {dependsOn,issues};
+}
 export async function reviewStatus(directory, state) {
-  if (state.reviewPolicy !== 1) return { compatibility: 'review-adoption-required', canProceed: false, pending: [], runs: [], documents: [], instruction: 'Preserve old results. Enable reviewPolicy: 1 with an empty reviewHistory after compatibility assessment; no historical approval is inferred.' };
   const map = await artifactMap(), documents = [], evidenceIssues = [], evidenceCache = new Map();
   for (const r of state.reviewHistory ?? []) {
     if (!evidenceCache.has(r.sourceRef)) { try { evidenceCache.set(r.sourceRef,await evidence(directory,state,r.sourceRef)); } catch { evidenceCache.set(r.sourceRef,null); } }
@@ -63,6 +105,11 @@ export async function reviewStatus(directory, state) {
     const { approved, checked, latest } = decisionFor(state, doc, digest);
     documents.push({ path: doc.path, version: doc.version, digest, selfCheck: checked?.id ?? null, approval: approved?.id ?? null, status: !digest ? 'unavailable' : approved && (evidenceIssues.includes(approved.id) || (checked && evidenceIssues.includes(checked.id))) ? 'evidence-changed' : approved ? 'approved' : latest?.kind === 'changes-requested' ? 'changes-requested' : latest?.kind === 'self-check' && latest.result === 'failed' ? 'self-check-failed' : checked ? 'pending' : 'self-check-required' });
   }
+  let limitedScope=false;
+  if(state.deliveryPolicy?.partialRef) {
+    try { await evidence(directory,state,state.deliveryPolicy.partialRef); limitedScope=true; }
+    catch { /* Report an unavailable scope basis; never silently grant an exception. */ }
+  }
   const runs = [], requirement = state.documentPolicy?.authority === 'adopted' ? 'scope' : 'prd';
   for (const [i, run] of state.stageRuns.entries()) {
     const spec = map.stages[run.stage];
@@ -75,11 +122,19 @@ export async function reviewStatus(directory, state) {
     const producers = state.stageRuns.slice(0, i).filter(r => r.outputRefs.some(out => run.inputRefs.some(input => out.split('#')[0] === input.split('#')[0]))).map(r => r.id);
     const development = ['requirements','scope','tech-design','contract','test-design','plan','implement'];
     const prerequisites = development.includes(run.stage) ? state.stageRuns.slice(0,i).filter(r=>development.includes(r.stage) && development.indexOf(r.stage)<development.indexOf(run.stage)).map(r=>r.id) : [];
-    const dependsOn = [...new Set([...declared, ...producers, ...prerequisites])];
-    const blockedBy = dependsOn.filter(id => !runs.find(r => r.id === id)?.ready);
+    const gated=state.deliveryPolicy?.version===1 && ['review','verify','handoff'].includes(run.stage);
+    const entrance=gated && !limitedScope ? standardEntry(state,run,i,runs) : {dependsOn:[],issues:[]};
+    if(gated && state.deliveryPolicy.partialRef && !limitedScope) entrance.issues.push('entry:limited-scope-evidence');
+    const dependsOn = [...new Set([...declared, ...producers, ...prerequisites,...entrance.dependsOn])];
+    const blockedBy = dependsOn.filter(id => {
+      const dependency = runs.find(r => r.id === id);
+      const original = state.stageRuns.find(r => r.id === id);
+      return !dependency?.releaseReady && !(dependency?.ready && reviewsResult(run, original));
+    });
+    blockedBy.push(...entrance.issues);
     // An omitted producer run must not turn an unapproved input into permission.
-    // Schema 1/2 retain their historical arrangement; new initialization uses schema 3.
-    if (state.schemaVersion === 3) {
+    // Schema 4 keeps prerequisite approvals even when producer runs are omitted.
+    if (state.schemaVersion === 4) {
       const needs = [];
       if (['prototype','tech-design','contract','test-design','plan','implement'].includes(run.stage)) needs.push(requirement);
       if (['contract','test-design','plan','implement'].includes(run.stage)) needs.push('tech-design');
@@ -97,13 +152,22 @@ export async function reviewStatus(directory, state) {
     }
     const waiting = required.filter(file => documents.find(d => d.path === file)?.status !== 'approved');
     const ready = run.progress === 'done' && !['needs-review','unknown'].includes(run.applicability) && !blockedBy.length && !waiting.length && (!spec?.humanReview || required.length > 0);
-    runs.push({ id: run.id, stage: run.stage, progress: run.progress, applicability: run.applicability, documents: required, waiting, dependsOn, blockedBy, ready });
+    const releaseReady = ready && (run.stage !== 'review' || run.result === 'passed');
+    runs.push({ id: run.id, stage: run.stage, progress: run.progress, applicability: run.applicability, documents: required, waiting, dependsOn, blockedBy, ready, releaseReady });
+    if (releaseReady && run.stage === 'review') {
+      for (const earlier of runs.slice(0,-1)) {
+        if (earlier.ready && reviewsResult(run, state.stageRuns.find(r=>r.id===earlier.id))) {
+          earlier.releaseReady = true;
+          earlier.resolvedBy = run.id;
+        }
+      }
+    }
   }
   const current = runs.find(r => r.id === state.currentRun);
   const pending = runs.filter(r => r.progress !== 'planned').flatMap(r => r.waiting.map(document => ({ run: r.id, document, status: documents.find(d => d.path === document)?.status })));
   const nextRun = runs.find(r => !r.ready);
   const nextStage = current ? runs[runs.indexOf(current) + 1]?.stage ?? null : nextRun?.stage ?? null;
-  return { compatibility: 'current', documents, runs, pending, evidenceIssues, currentRun: current?.id ?? null, nextRun: nextRun?.id ?? null, nextStage, canProceed: current ? !current.blockedBy.length && !(current.progress === 'done' && !current.ready) && current.progress !== 'blocked' && !['needs-review','unknown'].includes(current.applicability) : !pending.length && !runs.some(r=>r.progress==='blocked' || (r.progress !== 'planned' && r.blockedBy.length) || ['needs-review','unknown'].includes(r.applicability)), identity: 'Record validation only; user identity, intent and source authenticity are not authenticated.' };
+  return { compatibility: 'current', documents, runs, pending, evidenceIssues, currentRun: current?.id ?? null, nextRun: nextRun?.id ?? null, nextStage, canProceed: current ? !current.blockedBy.length && !(current.progress === 'done' && !current.releaseReady) && current.progress !== 'blocked' && !['needs-review','unknown'].includes(current.applicability) : !pending.length && !runs.some(r=>r.progress==='blocked' || (r.progress === 'done' && !r.releaseReady) || (r.progress !== 'planned' && r.blockedBy.length) || ['needs-review','unknown'].includes(r.applicability)), identity: 'Record validation only; user identity, intent and source authenticity are not authenticated.' };
 }
 async function evidence(directory, state, ref) {
   if (!text(ref) || ref.includes('\\') || ref.split('#')[0].split('/').includes('..') || ref.startsWith('/') || (/^[a-zA-Z]:/.test(ref) && !ref.startsWith('repo:'))) reject('Review evidence must stay inside a registered root.');
@@ -111,12 +175,12 @@ async function evidence(directory, state, ref) {
   try { body = await safeRead(directory, state, ref); } catch { reject(`Cannot read review evidence ${ref}.`); }
   if (!text(body)) reject(`Preserve locally readable review evidence for ${ref}.`);
   const fragment = ref.split('#')[1];
-  if (fragment && !anchors(body).includes(fragment)) reject(`Review evidence anchor not found: ${ref}.`);
+  if (fragment && !hasLocator(body,fragment,(await artifactMap()).documents[state.documents?.find(d=>d.mode==='new' && d.path===ref.split('#')[0])?.kind])) reject(`Review evidence locator not found: ${ref}.`);
   return hash(body);
 }
 export async function enforceReviews(directory, state, previous) {
   validateReviewState(state);
-  if (state.reviewPolicy !== 1) reject('Adopt the review protocol before workflow updates; old results remain readable but are not approvals.');
+  if (state.reviewPolicy !== 1) reject('Invalid review policy.');
   const oldHistory = previous?.reviewHistory ?? [];
   for (const old of previous?.documents ?? []) if (oldHistory.some(r=>r.document===old.path) && !state.documents.some(d=>d.path===old.path && d.kind===old.kind)) reject(`Preserve reviewed document registration ${old.path}.`);
   if (state.reviewHistory.length < oldHistory.length || !oldHistory.every((r, i) => isDeepStrictEqual(r, state.reviewHistory[i]))) reject('Preserve review history unchanged and in order.');

package/lib/cli.mjs

@@ -1,4 +1,6 @@
-import { migrateState, scanDeliveries } from './migrate.mjs';
+import { pathToFileURL } from 'node:url';
+import { text } from './language.mjs';
+import { scanDeliveries } from './discovery.mjs';
 import { inspectDocuments } from './documents.mjs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -11,17 +13,14 @@ const HELP = {
   usage: 'node <aimship.mjs> <command> [delivery-directory] [options]',
   commands: {
     render: 'render <dir> --revision <N> --rules-version <version> [--preserve-edits]. Explicitly rebuild status.md; preserve manual edits before replacement. Does not replay a state update.',
-    migrate: 'migrate <dir> --revision <old-N> --rules-version <active-version> --input <json-file|->. Input {compatibilityRef}; preserve legacy state then move to schema 2. Adopt rules separately; documents require reviewed reconciliation.',
-    scan: 'scan <material-root>. Read immediate delivery directories in both layouts, deduplicate IDs and report conflicts/unknown records. No global search or write.',
+    scan: 'scan <material-root>. Read immediate delivery directories at .aimship/state.json, deduplicate IDs and report conflicts or invalid records. No global search or write.',
     status: 'status [--home <dir>]. Read only Aimship-managed paths and fixed entries. Report registration, shared entry presence/integrity, active version, pending work and config problems. Host loading, login and access permissions remain unverified; no directories are created.',
     bind: 'Resolve active installation once. Returns immutable release/core/stage/CLI paths plus configured dataRoot, configPath and customPath. Source mode returns the default data root with null config/custom paths. No directories are created. Optional --home is for isolated testing.',
-    init: 'init <dir> --input <json-file|-> --rules-version <version>. Create state once; input requires goal.summary and saved source/request.md; endpoint and artifact conditions may remain null (unknown). Does not create templates.',
-    read: 'read <dir> [--rules-version <version>] [--delivery-id <known-id>]. Read-only JSON access; unknown schemas remain readable.',
+    init: 'init <dir> --input <json-file|-> --rules-version <version>. Create state once; input requires goal.summary, language (en or zh-CN) and saved source/request.md; directory must be a child of bound dataRoot unless storage has an explicit local decisionRef; endpoint and artifact conditions may remain null (unknown). Does not create templates.',
+    read: 'read <dir> [--rules-version <version>] [--delivery-id <known-id>]. Read current delivery state without executing work.',
     update: 'update <dir> --revision <N> --rules-version <version> --input <json-file|->. Recursively merge objects; arrays replace in full. Identity/history fields are managed. null is a literal value, not deletion.',
-    check: 'check <dir> [--rules-version <version>] [--all]. Check structure and current input references (or every registered reference). Checks explicit anchors/identity metadata in new local Markdown; reused and unsupported fragments are explicitly not checked. Does not prove semantics, remote access or validation results.',
+    check: 'check <dir> [--rules-version <version>] [--all]. Check structure and current input references (or every registered reference). Checks ordinary Markdown sections and searchable numbers in new local Markdown; reused and unsupported fragments are explicitly not checked. Does not prove semantics, remote access or validation results.',
     resume: 'resume <dir> [--rules-version <version>] [--delivery-id <known-id>]. Read state and return fixed rule paths, required inputs, warnings, and continuation text; never execute work or rewrite state.',
-    checkpoint: 'checkpoint <dir> --revision <N> --rules-version <old-version> --input <json-file|->. Save only checkpoint {summary, ref?} and next when a version mismatch interrupts ongoing work. Cannot complete work.',
-    adopt: 'adopt <dir> --revision <N> --rules-version <active-version> --input <json-file|->. Input is {compatibilityRef}; records the assessed stable-point rule switch without changing business history.',
     recover: 'recover <dir> --revision <backup-revision> --rules-version <version>. Restore state.previous.json only over missing/corrupt state; preserve corrupted bytes. Inspect actual artifacts afterward; nothing reruns.',
     install: 'install --host <codex|cursor|claude-code> [--host ...] [--data-root <dir>] [--home <dir>]. Explicitly copy the whole release into .aimship. Repeated installs retain registered hosts. Installed tools default to their owning home; explicit --home overrides it for isolated testing. Data root is configured, never created.',
     uninstall: 'uninstall [--host <host> ...] [--home <dir>]. --host disconnects selected hosts, retaining shared core even when no hosts remain. Omit --host for full product uninstall. Delivery data, config, custom and modified/unowned files are retained. Installed tools default to their owning home; explicit --home overrides it.',
@@ -30,18 +29,20 @@ const HELP = {
   stateProtocol: {
     schemaVersion: SCHEMA_VERSION,
     documentReview: {reviewPolicy:1, reviewHistory:'Append-only {id,kind,document,version,digest,sourceRef,summary}. self-check requires result: passed|failed; approved requires decision: explicit-approval; editorial requires previousDigest. Read review.documents for current digests. Tools validate records, not user identity. See docs/cli.md#document-review-protocol.'},
-    deliveryPolicy: 'New states default to {version:1}; partialRef identifies an explicitly limited scope, null restores standard scope with a new goal decision. Legacy absence remains historical-unassessed; explicit adoption requires compatibilityRef. Completion is derived separately from goal/acceptance.',
+    deliveryPolicy: 'New states default to {version:1}; partialRef identifies an explicitly limited scope, null restores standard scope with a new goal decision. Completion is derived separately from goal/acceptance.',
     sessions: 'run.sessionGroup is an advisory context group, auto-filled for new runs; reviewOf names implementation runs and overall:true identifies overall review. read/check/resume expose session/completion; writeResult.session is withheld on failed view saving. No session gate or automatic execution.',
     stages: STAGES,
     progress: ['planned', 'active', 'blocked', 'done'],
     result: ['passed', 'failed', 'not-run', 'unknown', 'mixed'],
     applicability: ['current', 'needs-review', 'unknown'],
     outcome: { goal: ['in-progress', 'met', 'not-met', 'unknown'], acceptance: ['not-recorded', 'accepted', 'declined', 'unknown'] },
-    stageInstance: { id: 'stable-instance-id', stage: '<stage>', scope: 'batch or whole-delivery scope', progress: 'planned', inputRefs: [], outputRefs: [], resultRef: 'review.md#rev-001-v1 (required when done)' },
+    stageInstance: { id: 'stable-instance-id', stage: '<stage>', scope: 'batch or whole-delivery scope', progress: 'planned', inputRefs: [], outputRefs: [], resultRef: 'review.md#REV-001 (required when done)' },
     references: 'delivery-relative/path#optional-fragment, repo:<registered-id>/<repo-relative-path>#fragment, or HTTP(S) URL. Local paths cannot escape their root. Repository registration: {id, path: absolute-path, role}.',
     topLevel: {
-      managed: 'schemaVersion, revision, deliveryId, rulesVersion, createdAt, updatedAt, goalHistory, rulesHistory, documentDigests, identityHistory, retiredIdentities, legacyRunIds, writeResult. Do not supply these in init/update.',
-      requiredInit: 'goal: {summary, endpoint?}; save a nonempty source/request.md before init. Defaults: endpoint null, goalRef source/request.md, empty documents, and null documentPolicy conditions/authority. Register PRD/Scope and switch goalRef when drafted; no empty templates.',
+      managed: 'schemaVersion, revision, deliveryId, rulesVersion, createdAt, updatedAt, goalHistory, documentDigests, writeResult. Do not supply these in init/update.',
+      requiredInit: 'language: en|zh-CN and goal: {summary, endpoint?}; save a nonempty source/request.md before init. Defaults: endpoint null, goalRef source/request.md, empty documents, and null documentPolicy conditions/authority. Register PRD/Scope and switch goalRef when drafted; no empty templates.',
+      language: 'en or zh-CN from explicit user preference, otherwise this delivery conversation. Required in current state; retained on update/render/resume.',
+      storage: 'Init-only {mode: explicit, decisionRef: delivery-relative-readable-file} for a user-selected location. Otherwise a strict child of configured dataRoot. Returned dataRoot is managed; ordinary workspace/material location is not a choice.',
       stageRuns: 'Ordered array of stageInstance objects, default []. Every ID is unique; currentRun must match one of these IDs or be null. Stage types may repeat with distinct IDs.',
       currentRun: 'Instance ID or null (default). Do not invent an ID without registering its instance in stageRuns.',
       repositories: 'Array of {id, path: absolute-path, role, ...optional-version-facts}, default []. No repository is required for a design-only goal.',
@@ -52,6 +53,7 @@ const HELP = {
       closureRefs: 'Historical closure references, default []. Preserve them across reopenings.'
     },
     minimalInit: {
+      language: 'en',
       goal: { summary: 'Export the currently filtered orders', endpoint: null },
       goalRef: 'source/request.md',
       documentPolicy: {authority:null,interaction:null,prototypeCovered:null,interface:null,databases:null},
@@ -117,11 +119,14 @@ async function binding(runtime) {
   if (configPath) {
     dataRoot = (await readConfig(configPath)).dataRoot;
   }
-  return { version: pkg.version, schemaVersion: SCHEMA_VERSION, launcherProtocol: 1, releaseRoot: root, corePath, stageDirectory: path.join(root, 'skills', 'aimship', 'references', 'stages'), cliPath: path.join(root, 'bin', 'aimship.mjs'), launcherPath: runtime.launcher, nodePath: process.execPath, dataRoot, configPath, customPath: runtime.installRoot ? path.join(runtime.installRoot, 'custom') : null, configurationStatus: runtime.installRoot ? 'installed' : 'source-default' };
+  const protocolPath=path.join(root,'lib/state.mjs'); await noSymlinks(protocolPath);
+  const targetProtocol = await import(pathToFileURL(protocolPath).href);
+  if (!Number.isSafeInteger(targetProtocol.SCHEMA_VERSION) || targetProtocol.SCHEMA_VERSION<1) fail('INCOMPLETE_RELEASE','Bound release does not export its state protocol.','Repair the exact release before creating state.');
+  return { version: pkg.version, schemaVersion: targetProtocol.SCHEMA_VERSION, toolVersion:runtime.version, toolSchemaVersion:SCHEMA_VERSION, launcherProtocol: 1, releaseRoot: root, corePath, stageDirectory: path.join(root, 'skills', 'aimship', 'references', 'stages'), cliPath: path.join(root, 'bin', 'aimship.mjs'), launcherPath: runtime.launcher, nodePath: process.execPath, dataRoot, configPath, customPath: runtime.installRoot ? path.join(runtime.installRoot, 'custom') : null, configurationStatus: runtime.installRoot ? 'installed' : 'source-default' };
 }
 function allowed(command, options) {
   const common = ['help', 'version'];
-  const perCommand = { render: ['revision','rules-version','preserve-edits','home'], migrate:['revision','rules-version','input','home'], scan:['home'], status: ['home'], bind: ['home'], init: ['input', 'rules-version', 'home'], read: ['rules-version', 'delivery-id', 'home'], update: ['input', 'rules-version', 'revision', 'home'], check: ['all', 'rules-version', 'home'], resume: ['rules-version', 'delivery-id', 'home'], checkpoint: ['input', 'rules-version', 'revision', 'home'], adopt: ['input', 'rules-version', 'revision', 'home'], recover: ['rules-version', 'revision', 'home'], install: ['hosts', 'home', 'data-root'], uninstall: ['hosts', 'home'], help: [] };
+  const perCommand = { render: ['revision','rules-version','preserve-edits','home'], scan:['home'], status: ['home'], bind: ['home'], init: ['input', 'rules-version', 'home'], read: ['rules-version', 'delivery-id', 'home'], update: ['input', 'rules-version', 'revision', 'home'], check: ['all', 'rules-version', 'home'], resume: ['rules-version', 'delivery-id', 'home'], recover: ['rules-version', 'revision', 'home'], install: ['hosts', 'home', 'data-root'], uninstall: ['hosts', 'home'], help: [] };
   for (const key of Object.keys(options)) if (![...common, ...(perCommand[command] ?? [])].includes(key)) fail('USAGE', `Option --${key} is not valid for ${command}.`, `Run help ${command}.`);
 }
 export async function run(argv, context) {
@@ -150,16 +155,17 @@ export async function run(argv, context) {
   if (command === 'bind') return { command, data: await binding(runtime) };
   const directory = path.resolve(positional[1]); const rulesVersion = options['rules-version'];
   if (command === 'render') return {command,data:await renderState(directory,revisionOf(options.revision),rulesVersion,runtime,options['preserve-edits'])};
-  if (command === 'migrate') return {command,data:await migrateState(directory,revisionOf(options.revision),rulesVersion,runtime,await inputJSON(options.input))};
-  if (command === 'init') return { command, data: await initState(directory, await inputJSON(options.input), rulesVersion, runtime) };
-  if (['update', 'checkpoint', 'adopt'].includes(command)) return { command, data: await updateState(directory, await inputJSON(options.input), revisionOf(options.revision), rulesVersion, runtime, command) };
+  if (command === 'init') {
+    const bound=await binding(runtime);
+    return { command, data: await initState(directory,await inputJSON(options.input),rulesVersion,{...runtime,dataRoot:bound.dataRoot}) };
+  }
+  if (command === 'update') return { command, data: await updateState(directory, await inputJSON(options.input), revisionOf(options.revision), rulesVersion, runtime) };
   if (command === 'recover') return { command, data: await recoverState(directory, revisionOf(options.revision), rulesVersion, runtime) };
   const read = await readState(directory);
   if (options['delivery-id'] && options['delivery-id'] !== read.state.deliveryId) fail('DELIVERY_ID_MISMATCH','This directory is not the bound delivery.','Locate the intended delivery; do not guess the latest one.');
   let mismatch = null;
-  if (!read.readOnly) { try { assertRules(read.state, rulesVersion, runtime); } catch (error) { mismatch = { code: error.code, ...error.details, recovery: error.recovery }; } }
-  if (command === 'read') return { command, data: { state: read.state, readOnly: read.readOnly, versionMismatch: mismatch, statePath: read.statePath, review:read.review, completion:read.completion, session:read.session, view: read.view, documentChanges: read.documentChanges, layoutConflict:read.conflict??false, layoutMismatch:read.layoutMismatch??false, candidates:read.candidates, migration:read.migration?.status??null } };
-  if (read.readOnly) return { command, data: { state: read.state, readOnly: true, canProceed: false, reason: read.conflict?'Conflicting state layouts require explicit reconciliation.':'Unknown schema: no structure checking, mutation, or automatic work is permitted.', candidates:read.candidates } };
+  try { assertRules(read.state, rulesVersion, runtime); } catch (error) { mismatch = { code: error.code, ...error.details, recovery: error.recovery }; }
+  if (command === 'read') return { command, data: { state: read.state, readOnly: read.readOnly, versionMismatch: mismatch, statePath: read.statePath, review:read.review, completion:read.completion, session:read.session, view: read.view, documentChanges: read.documentChanges } };
   validateState(read.state); const references = await checkReferences(directory, read.state, options.all);
   const documents=await inspectDocuments(directory,read.state);
   const missing = references.filter(x => !['exists', 'not-checked'].includes(x.status));
@@ -171,5 +177,5 @@ export async function run(argv, context) {
   }
   const currentRun = read.state.stageRuns.find(x => x.id === read.state.currentRun) ?? null;
   const blocked = currentRun?.progress === 'blocked';
-  return { command, data: { state: read.state, binding: await binding(runtime), readOnly: false, review:read.review, completion:read.completion, session:read.session, canProceed: read.review.canProceed && read.state.documentPolicy?.authority !== 'legacy' && !mismatch && missing.length === 0 && !blocked && !documents.issues.length && !read.documentChanges.length && read.view.status === 'current' && (!read.migration || read.migration.status === 'complete'), statePath:read.statePath, view:read.view, documentChanges:read.documentChanges, documents, versionMismatch: mismatch, references, currentRun, continuation: !mismatch && !missing.length && !documents.issues.length ? read.session?.continuation ?? null : null, warnings: ['Resume does not rerun work, tests, migrations, or other side effects.', 'Structural readiness does not establish authorization, business readiness, or goal completion.', ...(blocked ? [`Current run ${currentRun.id} is recorded as blocked. Resolve its documented blocker before progressing this work.`] : []), ...(missing.length ? ['Some required paths must be repaired.'] : []), ...(read.state.checkpoint ? ['Inspect the saved checkpoint and current artifacts.'] : [])] } };
+  return { command, data: { state: read.state, binding: await binding(runtime), readOnly: false, review:read.review, completion:read.completion, session:read.session, canProceed: read.review.canProceed && !mismatch && missing.length === 0 && !blocked && !documents.issues.length && !read.documentChanges.length && read.view.status === 'current', statePath:read.statePath, view:read.view, documentChanges:read.documentChanges, documents, versionMismatch: mismatch, references, currentRun, continuation: !mismatch && !missing.length && !documents.issues.length ? read.session?.continuation ?? null : null, warnings: [text(read.state,'Resume does not rerun work, tests, migrations, or other side effects.','续接不会重新执行工作、测试、迁移或其他外部操作。'), text(read.state,'Structural readiness does not establish authorization, business readiness, or goal completion.','结构检查就绪不代表已获得授权、业务已就绪或目标已完成。'), ...(blocked ? [text(read.state,`Current run ${currentRun.id} is recorded as blocked. Resolve its documented blocker before progressing this work.`,`当前工作 ${currentRun.id} 已记录为受阻，请先处理已记录的阻塞原因。`)] : []), ...(missing.length ? [text(read.state,'Some required paths must be repaired.','部分必要路径需要修复。')] : [])] } };
 }

package/lib/delivery.mjs

@@ -1,11 +1,11 @@
+import { text, completionMessage } from './language.mjs';
 import path from 'node:path';
 import { unknownConditions } from './documents.mjs';
 import { fail } from './io.mjs';
 
-// Additive policy: absent means historical, never inferred complete or rewritten on read.
+// Current delivery policy and completion checks.
 export function validateDelivery(state) {
   const p = state.deliveryPolicy;
-  if (p === undefined) return;
   if (!p || p.version !== 1) fail('INVALID_STATE', 'Unsupported delivery policy.', 'Preserve the state and use a compatible tool.');
   if (p.partialRef != null && (typeof p.partialRef !== 'string' || !p.partialRef.trim())) fail('INVALID_STATE', 'partialRef must identify the explicit scope decision.', 'Record the actual decision in the existing requirement or change record.');
   for (const r of state.stageRuns) {
@@ -24,9 +24,8 @@ export function arrangeSessions(state) {
   }
 }
 export function completionStatus(state, review, {changed=[]}={}) {
-  if (state.deliveryPolicy?.version !== 1) return {status:'historical-unassessed', standardComplete:false, readyForAcceptance:false, gaps:['Historical outcomes are preserved; explicitly adopt the delivery policy after assessing evidence.']};
   const runs=state.stageRuns, gaps=[];
-  if (state.schemaVersion === 3 && (state.goal.endpoint === null || state.documentPolicy.authority === null || unknownConditions(state.documentPolicy).length)) gaps.push('Endpoint or artifact conditions remain unknown.');
+  if (state.schemaVersion === 4 && (state.goal.endpoint === null || state.documentPolicy.authority === null || unknownConditions(state.documentPolicy).length)) gaps.push('Endpoint or artifact conditions remain unknown.');
   if(changed.length) gaps.push('Changed or missing registered documents require reconciliation.');
   const ready=r=>review.runs.find(x=>x.id===r.id)?.ready;
   const has=stage=>runs.some(r=>r.stage===stage && ready(r));
@@ -38,7 +37,7 @@ export function completionStatus(state, review, {changed=[]}={}) {
   const implementations=runs.filter(r=>r.stage==='implement');
   if (implementations.some(r=>['failed','mixed','unknown','not-run'].includes(r.result))) gaps.push('Implementation results remain unresolved.');
   const allReviews=runs.filter(r=>r.stage==='review');
-  const effectiveReviews=allReviews.filter((r,i)=>!allReviews.slice(i+1).some(later=>ready(later) && later.result==='passed' && later.historyResultRefs?.includes(r.resultRef)));
+  const effectiveReviews=allReviews.filter(r=>!review.runs.find(x=>x.id===r.id)?.resolvedBy);
   if (effectiveReviews.some(r=>!ready(r) || r.result!=='passed')) gaps.push('Review results remain unresolved.');
   const reviews=allReviews.filter(r=>ready(r) && r.result==='passed');
   for (const [i, batch] of implementations.entries()) {
@@ -54,7 +53,7 @@ export function completionStatus(state, review, {changed=[]}={}) {
   if (state.openChanges.some(c=>c.status==='open')) gaps.push('Unresolved changes remain.');
   const partial=!!state.deliveryPolicy.partialRef;
   const readyForAcceptance=!partial && !gaps.length;
-  return {status:partial?'partial-scope':readyForAcceptance && state.outcome.goal==='met' && state.outcome.acceptance==='accepted'?'standard-complete':readyForAcceptance?'ready-for-acceptance':'incomplete',standardComplete:readyForAcceptance && state.outcome.goal==='met' && state.outcome.acceptance==='accepted',readyForAcceptance,gaps,partialRef:state.deliveryPolicy.partialRef??null,scope:'Recorded structure, approvals and results only; not independent proof of test execution or semantic quality.'};
+  return {status:partial?'partial-scope':readyForAcceptance && state.outcome.goal==='met' && state.outcome.acceptance==='accepted'?'standard-complete':readyForAcceptance?'ready-for-acceptance':'incomplete',standardComplete:readyForAcceptance && state.outcome.goal==='met' && state.outcome.acceptance==='accepted',readyForAcceptance,gaps:gaps.map(g=>completionMessage(state,g)),partialRef:state.deliveryPolicy.partialRef??null,scope:text(state,'Recorded structure, approvals and results only; not independent proof of test execution or semantic quality.','仅评估已记录的结构、审批和结果；不独立证明测试已执行或内容语义正确。')};
 }
 export function sessionAdvice(directory,state,review,{saved=true}={}) {
   const groups=[];
@@ -65,14 +64,18 @@ export function sessionAdvice(directory,state,review,{saved=true}={}) {
   const status=review.runs.find(r=>r.id===state.currentRun);
   const pending=review.pending.some(p=>state.stageRuns.find(r=>r.id===p.run)?.progress==='done' || p.status==='changes-requested' || p.status==='self-check-failed');
   const next=current?state.stageRuns[state.stageRuns.indexOf(current)+1]:state.stageRuns.find(r=>r.progress!=='done');
+  const concluded=state.outcome.goal==='met' && review.runs.every(r=>r.ready)
+    && (!!state.deliveryPolicy?.partialRef || completionStatus(state,review).readyForAcceptance);
+  const last=state.stageRuns.at(-1);
+  const endAction=concluded?'finished':(current??last)?.stage==='handoff'?'assess-outcome':'arrange-next';
   let action='continue-current';
   if (!saved) action='reconcile-save';
-  else if(state.deliveryPolicy?.version !== 1) action='assess-compatibility';
   else if(pending) action='await-review';
-  else if(!current && state.stageRuns.length && review.runs.every(r=>r.ready)) action='finished';
-  else if(current && (['failed','mixed','unknown','not-run'].includes(current.result) || current.progress==='blocked' || ['needs-review','unknown'].includes(current.applicability))) action='resolve-current';
-  else if(status?.ready) action=!next?'finished':next.progress!=='planned'?'inspect-existing-work':current.sessionGroup && current.sessionGroup===next.sessionGroup?'continue-group':'suggest-new-session';
+  else if(!current && state.stageRuns.length && review.runs.every(r=>r.ready)) action=concluded?endAction:review.runs.some(r=>r.releaseReady===false)?'resolve-current':endAction;
+  else if(current && ((!status?.resolvedBy && (['failed','mixed','unknown','not-run'].includes(current.result) || (current.stage==='review' && current.progress==='done' && !status?.releaseReady))) || current.progress==='blocked' || ['needs-review','unknown'].includes(current.applicability))) action=concluded && !next?'finished':'resolve-current';
+  else if(status?.ready) action=!next?endAction:next.progress!=='planned'?'inspect-existing-work':current.sessionGroup && current.sessionGroup===next.sessionGroup?'continue-group':'suggest-new-session';
   if (saved && !pending && state.deliveryPolicy?.version === 1 && status?.ready && next && review.runs.find(r=>r.id===next.id)?.blockedBy.length) action='resolve-current';
-  const continuation=['assess-compatibility','reconcile-save','await-review','finished'].includes(action)?null:`Use Aimship to continue delivery ${JSON.stringify(path.resolve(directory))}; first read its current state and relevant formal documents, then continue the recorded work.`;
-  return {action,currentRun:current?.id??null,nextRun:next?.id??null,groups,continuation,advisory:true,note:'A session boundary is not a blocker or approval. Continue here when requested. Resolve the delivery identity, current approvals and unfinished effects on every resume; this text grants no approval.'};
+  const instruction=action==='arrange-next'?text(state,'The recorded work has ended, but the delivery goal remains open. Read the agreed endpoint and saved next action; arrange only the next authorized work, or record an evidenced scope conclusion.','已登记工作已完成，但交付目标尚未结束。请读取约定终点与已保存的下一步，安排下一项已授权工作，或依据实际证据记录范围结论。'):action==='assess-outcome'?text(state,'Review the handoff against the agreed goal and record the actual goal conclusion and acceptance; completed handoff alone does not end the delivery.','请对照约定目标审阅交付材料，记录实际目标结论和用户接受结果；完成交付文档不等于交付已结束。'):null;
+  const continuation=['reconcile-save','await-review','assess-outcome','finished'].includes(action)?null:text(state,`Use Aimship to continue delivery ${JSON.stringify(path.resolve(directory))}; first read its current state and relevant formal documents, then continue the recorded work.${instruction?' '+instruction:''}`,`使用 Aimship 继续交付「${path.resolve(directory)}」，先读取当前状态和相关正式文档再接续。${instruction??''}`);
+  return {action,currentRun:current?.id??null,nextRun:next?.id??null,groups,continuation,instruction,advisory:true,note:text(state,'A session boundary is not a blocker or approval. Continue here when requested. Resolve the delivery identity, current approvals and unfinished effects on every resume; this text grants no approval.','会话边界不是阻塞或批准。用户要求时可在当前会话继续。每次续接都需核对交付身份、当前审批和未完成事项；本提示不授予权限。')};
 }

package/lib/discovery.mjs

@@ -0,0 +1,25 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { exists, noSymlinks } from './io.mjs';
+import { readState } from './state.mjs';
+
+
+// Discovery is intentionally bounded to named material roots, never the home or code tree.
+export async function scanDeliveries(root) {
+  const records=[],issues=[],seen=new Map();
+  for(const entry of await fs.readdir(root,{withFileTypes:true})) {
+    if(entry.name.startsWith('.')) continue;
+    const directory=path.join(root,entry.name);
+    if(entry.isSymbolicLink()) {issues.push({directory,reason:'SYMLINK'}); continue;}
+    if(!entry.isDirectory()) continue;
+    try {
+      await noSymlinks(path.join(directory,'.aimship/state.json'));
+      if(!await exists(path.join(directory,'.aimship/state.json'))) continue;
+      const read=await readState(directory), id=read.state.deliveryId;
+      if(seen.has(id)) {issues.push({directory,reason:'duplicate-delivery-id',other:seen.get(id)}); continue;}
+      seen.set(id,directory);
+      records.push({directory,statePath:read.statePath,deliveryId:id,rulesVersion:read.state.rulesVersion,repositories:read.state.repositories,currentRun:read.state.currentRun,stageRuns:read.state.stageRuns,outcome:read.state.outcome,next:read.state.next,updatedAt:read.state.updatedAt});
+    } catch(error) {issues.push({directory,reason:error.code??error.message});}
+  }
+  return {root:path.resolve(root),records,issues,limits:'Named root immediate children only. Records may be stale; unknown roots and non-Aimship work are outside this check. Agent must assess actual writing intent and checkout/worktree identity.'};
+}