@namewta/speculo 1.0.24 → 2.0.2

package/template/workflows/specdev/common/tools/validate-specdev.mjs

@@ -19,46 +19,51 @@ import {
 import { execFileSync } from "node:child_process";
 import { dirname, basename, extname, join, relative, resolve, sep, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
+import { parseFrontmatter as parseYaml, validateSkill } from "../../../../lib/speculo-runtime.mjs";
+
+import * as runtime from "../../../../lib/speculo-runtime.mjs";
 
 import {
   validateTicketPlan, validatePlanMap, validateInvocationCoverage,
-  validateGoalMap, validateInitiative, resolveProjectSource,
+  validateGoalMap, validateInitiative, resolveProjectSource, readChangeExecution, readSpecification, resolveToolContext, validateExecutionPolicy, canonicalToolPath, resolveSnapshotContext, readLightweightGoal, validateAcceptanceEvidence,
 } from "./plan-contract.mjs";
 
+import { validateChangeClosure, readChangeOwner } from "./change-artifacts.mjs";
 import { validateRecord, validateRecords } from "./delivery-artifacts.mjs";
 import { reviewScopeCLI } from "./review-scope.mjs";
 import { ENGINEERING_KINDS, validateEngineeringArtifacts, validateEngineeringPackage } from "./engineering-evidence.mjs";
 
 const DOMAIN_SCHEMA_VERSION = 3;
-const CONFIG_SCHEMA_VERSION = 6;
-const GOAL_PLAN_SCHEMA_VERSION = 6;
+const CONFIG_SCHEMA_VERSION = 7;
+const GOAL_PLAN_SCHEMA_VERSION = 7;
 const IMPLEMENTATION_MAP_SCHEMA_VERSION = 1;
-const IMPLEMENTATION_PLAN_SCHEMA_VERSION = 1;
+const IMPLEMENTATION_PLAN_SCHEMA_VERSION = 2;
 const CHANGE_STATUS_SCHEMA_VERSION = 6;
 const GLOBAL_STATUS_SCHEMA_VERSION = 5;
 const WORKFLOW_PREFIX = "{roots.workflows}/specdev/";
 const STATE_PREFIX = "{roots.state}/specdev/";
 const STATE_ROOT_PREFIX = "{roots.state}/";
+const REFERENCES_PREFIX = "{roots.references}/";
 const SKILLS_PREFIX = "{roots.skills}/";
 const COMMANDS_PREFIX = "{roots.commands}/";
 const CHANGE_NAME = /^[0-9]{4}-[0-9]{2}-[0-9]{2}-[a-z0-9]+(?:-[a-z0-9]+)*$/;
 
 const EXPECTED_WORKS = new Set([
-  "A-archive-and-consolidate",
-  "C-code-review",
-  "D-diagnose-bugs",
-  "G-grill-with-docs",
-  "I-implement",
-  "I-init-setup",
-  "L-learn-change",
-  "P-goal-plan",
-  "P-prototype",
-  "R-review-architecture",
-  "R-retro",
-  "S-spec",
-  "T-tickets",
-  "T-triage",
-  "W-wayfinder",
+  "specdev-a-archive-and-consolidate",
+  "specdev-c-code-review",
+  "specdev-d-diagnose-bugs",
+  "specdev-g-grill-with-docs",
+  "specdev-i-implement",
+  "specdev-i-init-setup",
+  "specdev-l-learn",
+  "specdev-p-goal-plan",
+  "specdev-p-prototype",
+  "specdev-r-review-architecture",
+  "specdev-r-retro",
+  "specdev-s-spec",
+  "specdev-t-tickets",
+  "specdev-t-triage",
+  "specdev-w-wayfinder",
 ]);
 const EXPECTED_COMMON_DIRS = new Set(["rules", "schemas", "skills", "tools"]);
 const VALID_TICKET_STATUS = new Set([
@@ -167,13 +172,15 @@ const VALID_STAGES = new Set([
   "tickets",
   "goal-plan",
   "implement",
-  "learn-change",
+  "learn",
   "retro",
   "pr-delivery",
   "review",
   "prototype",
   "wayfinder",
   "complete",
+  "archive-ready",
+  "archived",
 ]);
 const REQUIRED_TICKET_KEYS = new Set([
   "schema_version",
@@ -214,7 +221,7 @@ const REQUIRED_GOAL_PLAN_SECTIONS = new Set([
 ]);
 const REQUIRED_LEAD_GOAL_PLAN_MARKERS = [
   "### Lead Orchestration",
-  "Implementation subagents",
+  "Concurrent implementations",
   "Read-only agents",
   "execution-time dynamic",
   "### Ticket Workspace and Integration",
@@ -269,7 +276,7 @@ function toPosix(value) {
 }
 
 function readText(path) {
-  return readFileSync(path, "utf8");
+  return runtime.readUtf8ArtifactSync(path);
 }
 
 function isFile(path) {
@@ -291,196 +298,17 @@ function walk(root) {
   return paths;
 }
 
-function parseScalar(raw) {
-  const value = raw.trim();
-  if (value === "true" || value === "True") return true;
-  if (value === "false" || value === "False") return false;
-  if (value === "null" || value === "Null" || value === "~") return null;
-  if (/^-?\d+$/.test(value)) return Number(value);
-  if (
-    (value.startsWith('"') && value.endsWith('"')) ||
-    (value.startsWith("'") && value.endsWith("'"))
-  ) {
-    return value.slice(1, -1);
-  }
-  if (value.startsWith("[") && value.endsWith("]")) {
-    // JSON object arrays are used by the additive Skill invocation contract.
-    // Keep the existing plain YAML scalar-list form for old artifacts.
-    try { return JSON.parse(value); } catch { /* legacy scalar list below */ }
-    const inner = value.slice(1, -1).trim();
-    if (inner.startsWith("{")) throw new Error("invalid JSON object array in frontmatter");
-    if (!inner) return [];
-    return inner.split(",").map((item) => parseScalar(item));
-  }
-  if (value.startsWith("{") && value.endsWith("}")) {
-    try {
-      return JSON.parse(value);
-    } catch {
-      return value;
-    }
-  }
-  return value;
-}
-
-function findSpecdevConfigByAncestry(change) {
-  let current = resolve(change);
-  while (true) {
-    const candidate = join(current, ".speculo", "specdev", "config.json");
-    if (isFile(candidate)) {
-      try {
-        return JSON.parse(readText(candidate));
-      } catch {
-        return null;
-      }
-    }
-    const parent = dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-
-function uniqueResolved(paths) {
-  const seen = new Set();
-  const result = [];
-  for (const path of paths) {
-    const resolved = resolve(path);
-    if (seen.has(resolved)) continue;
-    seen.add(resolved);
-    result.push(resolved);
-  }
-  return result;
-}
-
-function ancestorsOf(start) {
-  const dirs = [];
-  let current = resolve(start);
-  while (true) {
-    dirs.push(current);
-    const parent = dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return dirs;
-}
-
-function parseWorkspaceCandidate(filePath, projectRoot) {
-  if (!isFile(filePath)) return null;
-  let data;
+function resolveWorkspaceContract(repoRoot, change, options = {}) {
   try {
-    data = JSON.parse(readText(filePath));
-  } catch {
-    return null;
-  }
-  if (!data || typeof data !== "object" || Array.isArray(data)) return null;
-  if (data.schema_version !== 1 || data.path_base !== "project-root") return null;
-  const state = data.roots?.state;
-  if (typeof state !== "string" || !state.trim()) return null;
-  const declared = toPosix(state).replace(/^\.?\//, "").replace(/\/$/, "");
-  if (
-    !declared ||
-    declared.split("/").includes("..") ||
-    isAbsolute(declared) ||
-    ABSOLUTE_MACHINE_PATH_RE.test(declared)
-  ) {
-    return null;
-  }
-  const expected = resolve(projectRoot, declared, "workspace.json");
-  if (expected !== resolve(filePath)) return null;
-  return {
-    filePath: resolve(filePath),
-    projectRoot: resolve(projectRoot),
-    stateDeclared: declared,
-    stateRoot: resolve(projectRoot, declared),
-    data,
-  };
-}
-
-function workspaceProbes(projectRoot) {
-  const root = resolve(projectRoot);
-  return [
-    { projectRoot: root, filePath: join(root, "speculo", ".speculo", "workspace.json") },
-    { projectRoot: root, filePath: join(root, ".speculo", "workspace.json") },
-  ];
-}
-
-function collectWorkspaceCandidates(repoRoot, change) {
-  const probes = [];
-  if (repoRoot) {
-    probes.push(...workspaceProbes(repoRoot));
-  } else {
-    for (const dir of uniqueResolved([...ancestorsOf(change), ...ancestorsOf(process.cwd())])) {
-      probes.push(...workspaceProbes(dir));
-    }
-  }
-  const found = new Map();
-  for (const probe of probes) {
-    const parsed = parseWorkspaceCandidate(probe.filePath, probe.projectRoot);
-    if (!parsed) continue;
-    if (!found.has(parsed.filePath)) found.set(parsed.filePath, parsed);
-  }
-  return [...found.values()];
-}
-
-function isLegalChangeLocation(changeAbs, stateRoot) {
-  const name = basename(changeAbs);
-  if (resolve(stateRoot, "specdev", "changes", name) === changeAbs) return true;
-  const monthDir = dirname(changeAbs);
-  const archiveRoot = dirname(monthDir);
-  return (
-    /^\d{4}-\d{2}$/.test(basename(monthDir)) &&
-    resolve(stateRoot, "specdev", "archive") === archiveRoot &&
-    basename(changeAbs) === name
-  );
-}
-
-function resolveWorkspaceContract(repoRoot, change) {
-  const changeAbs = resolve(change);
-  const candidates = collectWorkspaceCandidates(repoRoot, changeAbs);
-  if (!candidates.length) {
-    return { mode: "legacy", errors: [], config: null, specdevRoot: null, stateDeclared: null };
-  }
-  const uniqueRoots = uniqueResolved(candidates.map((candidate) => candidate.stateRoot));
-  if (uniqueRoots.length > 1) {
-    const declared = [...new Set(candidates.map((candidate) => candidate.stateDeclared))].sort();
-    return {
-      mode: "strict",
-      errors: [`conflicting workspace.json roots.state (${declared.join(" vs ")})`],
-      config: null,
-      specdevRoot: null,
-      stateDeclared: null,
-    };
-  }
-  const workspace = candidates[0];
-  const specdevRoot = join(workspace.stateRoot, "specdev");
-  const errors = [];
-  if (!isLegalChangeLocation(changeAbs, workspace.stateRoot)) {
-    errors.push(
-      `change is outside workspace roots.state (${workspace.stateDeclared}/specdev); project-root .speculo/specdev is illegal`,
-    );
-  }
-  let config = null;
-  const configPath = join(specdevRoot, "config.json");
-  if (isFile(configPath)) {
-    try {
-      config = JSON.parse(readText(configPath));
-    } catch {
-      config = null;
-    }
-  }
-  return {
-    mode: "strict",
-    errors,
-    config,
-    specdevRoot,
-    stateDeclared: workspace.stateDeclared,
-  };
-}
-
-function findSpecdevConfig(change, repoRoot = null) {
-  const contract = resolveWorkspaceContract(repoRoot, change);
-  if (contract.mode === "strict") return contract.config;
-  return findSpecdevConfigByAncestry(change);
+    const context = options.readOnlySnapshot ? resolveSnapshotContext(options.readOnlySnapshot) : resolveToolContext(change, { ...options, repoRoot });
+    const location = runtime.resolveChangeSync(context, basename(change), { includeArchived: true });
+    const errors = canonicalToolPath(context, change) === location.root ? [] : ["change is outside the declared state root"];
+    const configPath = join(context.specdevRoot, "config.json");
+    const config = existsSync(configPath) ? JSON.parse(readText(runtime.safeWorkPathSync(context.specdevRoot, 'config.json', {mustExist:true,type:'file'}))) : null;
+    return { context, errors, config, specdevRoot:context.specdevRoot, stateDeclared:relative(context.projectRoot,context.stateRoot) };
+  } catch(error) { return {errors:[String(error)],config:null,specdevRoot:null}; }
 }
+function findSpecdevConfig(change,repoRoot=null,options={}) {return resolveWorkspaceContract(repoRoot,change,options).config;}
 
 function positiveConfigLimit(config, key, fallback) {
   const value = config?.execution?.[key];
@@ -488,37 +316,10 @@ function positiveConfigLimit(config, key, fallback) {
 }
 
 function parseFrontmatter(path) {
-  const text = readText(path);
-  const lines = text.split(/\r?\n/);
-  if (lines[0]?.trim() !== "---") return { meta: {}, body: text };
-  const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
-  if (end < 0) return { meta: {}, body: text };
-
-  const meta = {};
-  let currentListKey = null;
-  for (const line of lines.slice(1, end)) {
-    const stripped = line.trim();
-    if (!stripped || stripped.startsWith("#")) continue;
-    if (currentListKey && /^\s+-\s+/.test(line)) {
-      meta[currentListKey].push(parseScalar(line.replace(/^\s+-\s+/, "")));
-      continue;
-    }
-    currentListKey = null;
-    const colon = line.indexOf(":");
-    if (colon < 0) continue;
-    const key = line.slice(0, colon).trim();
-    if (["__proto__", "constructor", "prototype"].includes(key) || Object.hasOwn(meta, key)) {
-      throw new Error(`${path}: duplicate or unsafe frontmatter key ${key}`);
-    }
-    const raw = line.slice(colon + 1).trim();
-    if (!raw) {
-      meta[key] = [];
-      currentListKey = key;
-    } else {
-      meta[key] = parseScalar(raw);
-    }
-  }
-  return { meta, body: lines.slice(end + 1).join("\n") };
+  const text=readText(path);
+  if(!text.startsWith("---"))return {meta:{},body:text};
+  const parsed=parseYaml(text);
+  return {meta:parsed.fields,body:parsed.body};
 }
 
 function escapeRegExp(value) {
@@ -661,7 +462,7 @@ function validatePathValue(value, { allowProject = true } = {}) {
     }
     return null;
   }
-  for (const [prefix, name] of [[SKILLS_PREFIX, "skills"], [COMMANDS_PREFIX, "commands"]]) {
+  for (const [prefix, name] of [[SKILLS_PREFIX, "skills"], [REFERENCES_PREFIX,"references"], [COMMANDS_PREFIX, "commands"]]) {
     if (value.startsWith(prefix)) {
       const suffix = value.slice(prefix.length);
       if (
@@ -698,12 +499,13 @@ function validateDocumentReferences(root) {
   const entries = walk(root);
   const frozenResearchRoot = join(
     root,
-    "P-prototype",
+    "specdev-p-prototype",
     "design-library",
     "research-snapshot",
   );
+  const upstreamRoot = join(root, "specdev-p-prototype", "design-library", "upstream");
   const governedEntries = entries.filter(
-    (path) => path !== frozenResearchRoot && !path.startsWith(`${frozenResearchRoot}${sep}`),
+    (path) => ![frozenResearchRoot, upstreamRoot].some(frozen => path === frozen || path.startsWith(`${frozen}${sep}`)),
   );
   const knownFiles = new Set(governedEntries.filter(isFile).map((path) => basename(path)));
   const knownDirectories = new Set(governedEntries.filter(isDirectory).map((path) => basename(path)));
@@ -750,13 +552,13 @@ function validateDocumentReferences(root) {
             );
           }
         }
-      } else if (payload.startsWith(SKILLS_PREFIX) || payload.startsWith(COMMANDS_PREFIX)) {
-        const isSkill = payload.startsWith(SKILLS_PREFIX);
-        const prefix = isSkill ? SKILLS_PREFIX : COMMANDS_PREFIX;
+      } else if (payload.startsWith(REFERENCES_PREFIX) || payload.startsWith(COMMANDS_PREFIX)) {
+        const isSkill = payload.startsWith(REFERENCES_PREFIX);
+        const prefix = isSkill ? REFERENCES_PREFIX : COMMANDS_PREFIX;
         const referenced = payload.slice(prefix.length);
         if (!PLACEHOLDER_RE.test(referenced)) {
           const templateRoot = resolve(root, "..", "..");
-          const target = join(templateRoot, isSkill ? "skills" : "commands", referenced);
+          const target = join(templateRoot, isSkill ? "references" : "commands", referenced);
           if (!existsSync(target)) {
             errors.push(`${label}:${lineNumber(text, match.index)}: broken public Path ${payload}`);
           }
@@ -771,15 +573,29 @@ function validateDocumentReferences(root) {
       }
     }
 
+    const workSegment = toPosix(relative(root, path)).split("/")[0];
+    const skillRoot = EXPECTED_WORKS.has(workSegment) ? join(root, workSegment) : null;
+    const acceptedLinks = [];
     for (const match of text.matchAll(RELATIVE_MD_LINK_RE)) {
-      errors.push(
-        `${label}:${lineNumber(text, match.index)}: relative Markdown link is forbidden: ${match[1]}`,
-      );
+      const target = resolve(dirname(path), match[1].split("#")[0]);
+      if (skillRoot && target.startsWith(`${skillRoot}${sep}`) && existsSync(target)) acceptedLinks.push(match[0]);
+      else errors.push(`${label}:${lineNumber(text, match.index)}: relative Markdown link crosses its Skill package or is missing: ${match[1]}`);
+    }
+    // Browser assets need executable relative href/src values, not agent Path
+    // tags. Accept only existing targets inside the same Work package.
+    if (extname(path).toLowerCase() === ".html" && skillRoot) {
+      for (const match of text.matchAll(/(?:href|src)=["']([^"'#]+)(?:#[^"']*)?["']/g)) {
+        if (/^[a-z]+:|^\/\//i.test(match[1])) continue;
+        const target = resolve(dirname(path), match[1]);
+        if (target.startsWith(`${skillRoot}${sep}`) && existsSync(target)) acceptedLinks.push(match[0]);
+        else errors.push(`${label}: browser asset link crosses its Skill package or is missing: ${match[1]}`);
+      }
     }
 
     let withoutTags = text
       .replace(/`?\s*<Path>.*?<\/Path>\s*`?/gs, "")
       .replace(/`?\s*<Url>.*?<\/Url>\s*`?/gs, "");
+    for (const link of acceptedLinks) withoutTags = withoutTags.replaceAll(link, "");
 
     for (const match of withoutTags.matchAll(/\{roots\.(?:workflows|state)\}/g)) {
       errors.push(
@@ -852,29 +668,8 @@ function validateJsonFiles(root) {
 
 function validateGlobalStatusAssets(root) {
   const errors = [];
-  const paths = [join(root, "I-init-setup", "status-template.json")];
-  if (isDirectory(join(root, "_state"))) {
-    paths.unshift(join(root, "_state", "status.json"));
-  }
-  for (const path of paths) {
-    if (!isFile(path)) {
-      errors.push(`missing global status seed ${toPosix(relative(root, path))}`);
-      continue;
-    }
-    const data = JSON.parse(readText(path));
-    const keys = Object.keys(data).sort();
-    const expected = ["active", "archived", "schema_version", "workflow"];
-    if (JSON.stringify(keys) !== JSON.stringify(expected)) {
-      errors.push(`${toPosix(relative(root, path))}: global status must contain only ${expected.join(", ")}`);
-    }
-    if (
-      data.schema_version !== GLOBAL_STATUS_SCHEMA_VERSION ||
-      data.workflow !== "specdev" ||
-      !Array.isArray(data.active) ||
-      !Array.isArray(data.archived)
-    ) {
-      errors.push(`${toPosix(relative(root, path))}: invalid SpecDev global status v5 seed`);
-    }
+  for (const path of [join(root,"_state/status.json"),join(root,"specdev-i-init-setup/assets/status-template.json"),join(root,"specdev-i-init-setup/assets/change-status-template.json")]) {
+    if (existsSync(path)) errors.push(`retired business status must not be distributed as a new seed: ${toPosix(relative(root,path))}`);
   }
 
   const schemaPath = join(root, "common", "schemas", "status.schema.json");
@@ -900,8 +695,7 @@ function validateGlobalStatusAssets(root) {
 
 function validateExecutionContractAssets(root) {
   const errors = [];
-  const configTemplatePath = join(root, "I-init-setup", "config-template.json");
-  const changeTemplatePath = join(root, "I-init-setup", "change-status-template.json");
+  const configTemplatePath = join(root, "specdev-i-init-setup", "assets/config-template.json");
   const configSchemaPath = join(root, "common", "schemas", "config.schema.json");
   const goalPlanSchemaPath = join(root, "common", "schemas", "goal-plan.schema.json");
   const changeSchemaPath = join(root, "common", "schemas", "change-status.schema.json");
@@ -910,7 +704,6 @@ function validateExecutionContractAssets(root) {
 
   for (const path of [
     configTemplatePath,
-    changeTemplatePath,
     configSchemaPath,
     goalPlanSchemaPath,
     changeSchemaPath,
@@ -924,8 +717,8 @@ function validateExecutionContractAssets(root) {
   const configTemplate = JSON.parse(readText(configTemplatePath));
   if (
     configTemplate.schema_version !== CONFIG_SCHEMA_VERSION ||
-    !Number.isInteger(configTemplate.execution?.max_implementation_agents) ||
-    configTemplate.execution.max_implementation_agents < 1 ||
+    !Number.isInteger(configTemplate.execution?.max_concurrent_implementations) ||
+    configTemplate.execution.max_concurrent_implementations < 1 ||
     !Number.isInteger(configTemplate.execution?.max_integration_attempts) ||
     configTemplate.execution.max_integration_attempts < 1 ||
     !Number.isInteger(configTemplate.planning?.ui_design_default_candidates) ||
@@ -934,7 +727,7 @@ function validateExecutionContractAssets(root) {
     configTemplate.planning.ui_design_max_candidates > 4 ||
     configTemplate.planning.ui_design_max_candidates < configTemplate.planning.ui_design_default_candidates
   ) {
-    errors.push("config-template.json must define SpecDev config v6 with positive execution limits and valid UI design candidate bounds");
+    errors.push("config-template.json must define SpecDev config v7 with positive execution limits and valid UI design candidate bounds");
   }
   for (const obsolete of ["auto_commit", "worktree_for_parallel", "max_parallel"]) {
     if (JSON.stringify(configTemplate).includes(`\"${obsolete}\"`)) {
@@ -943,38 +736,29 @@ function validateExecutionContractAssets(root) {
   }
 
   const configSchema = JSON.parse(readText(configSchemaPath));
-  const limit = configSchema.properties?.execution?.properties?.max_implementation_agents;
+  const limit = configSchema.properties?.execution?.properties?.max_concurrent_implementations;
   if (
-    configSchema.$id !== "urn:speculo:specdev:config:v6" ||
+    configSchema.$id !== "urn:speculo:specdev:config:v7" ||
     configSchema.properties?.schema_version?.const !== CONFIG_SCHEMA_VERSION ||
     limit?.minimum !== 1 ||
     configSchema.properties?.execution?.properties?.max_integration_attempts?.minimum !== 1 ||
     configSchema.additionalProperties !== false
   ) {
-    errors.push("config.schema.json must define the strict SpecDev config v6 execution contract");
+    errors.push("config.schema.json must define the strict SpecDev config v7 execution contract");
   }
 
   const goalPlanSchema = JSON.parse(readText(goalPlanSchemaPath));
   if (
-    goalPlanSchema.$id !== "urn:speculo:specdev:goal-plan:v6" ||
+    goalPlanSchema.$id !== "urn:speculo:specdev:goal-plan:v7" ||
     goalPlanSchema.properties?.schema_version?.const !== GOAL_PLAN_SCHEMA_VERSION ||
     goalPlanSchema.properties?.orchestration?.const !== "lead-directed" ||
-    goalPlanSchema.properties?.implementation_agent_limit?.minimum !== 1 ||
+    goalPlanSchema.properties?.concurrent_implementation_limit?.minimum !== 1 ||
     goalPlanSchema.properties?.integration_attempt_limit?.minimum !== 1 ||
     !["current", "required"].every((value) => goalPlanSchema.properties?.ticket_workspace_policy?.enum?.includes(value)) ||
     !["direct-parent", "candidate-merge"].every((value) => goalPlanSchema.properties?.integration_gate?.enum?.includes(value)) ||
     goalPlanSchema.additionalProperties !== false
   ) {
-    errors.push("goal-plan.schema.json must define the strict Lead-directed Goal Plan v6 workspace strategy contract");
-  }
-
-  const changeTemplate = JSON.parse(readText(changeTemplatePath));
-  if (
-    changeTemplate.schema_version !== CHANGE_STATUS_SCHEMA_VERSION ||
-    changeTemplate.artifact !== "change-status" ||
-    !Array.isArray(changeTemplate.worktrees)
-  ) {
-    errors.push("change-status-template.json must define the SpecDev change-status v6 seed");
+    errors.push("goal-plan.schema.json must define the strict Lead-directed Goal Plan v7 workspace strategy contract");
   }
 
   const changeSchema = JSON.parse(readText(changeSchemaPath));
@@ -1001,10 +785,10 @@ function validateExecutionContractAssets(root) {
   }
   const implementationPlanSchema = JSON.parse(readText(implementationPlanSchemaPath));
   if (
-    implementationPlanSchema.$id !== "urn:speculo:specdev:implementation-plan:v1" ||
+    implementationPlanSchema.$id !== "urn:speculo:specdev:implementation-plan:v2" ||
     implementationPlanSchema.properties?.schema_version?.const !== IMPLEMENTATION_PLAN_SCHEMA_VERSION ||
     implementationPlanSchema.properties?.orchestration?.const !== "lead-directed" ||
-    implementationPlanSchema.properties?.implementation_agent_limit?.minimum !== 1 ||
+    implementationPlanSchema.properties?.concurrent_implementation_limit?.minimum !== 1 ||
     implementationPlanSchema.properties?.integration_attempt_limit?.minimum !== 1 ||
     !["current", "required"].every((value) => implementationPlanSchema.properties?.ticket_workspace_policy?.enum?.includes(value)) ||
     implementationPlanSchema.additionalProperties !== false
@@ -1019,12 +803,12 @@ function capabilityChecks(root) {
     [
       "init",
       [
-        join(root, "I-init-setup", "I-init-setup.md"),
+        join(root, "specdev-i-init-setup", "SKILL.md"),
         [
-          "tracking-template",
-          "domain-layout-template",
-          "config-template",
-          "change-status-template",
+          "first-setup.md",
+          "current-facts-docs.md",
+          "必要偏好",
+          "README",
           "specdev-worktree/",
         ],
       ],
@@ -1032,28 +816,28 @@ function capabilityChecks(root) {
     [
       "triage",
       [
-        join(root, "T-triage", "T-triage.md"),
+        join(root, "specdev-t-triage", "SKILL.md"),
         ["intake", "reconcile", "publish", "capture", "capture.md", "pr-delivery", "ci-security", "release-preflight", "recover", "remote-operations.md"],
       ],
     ],
     [
       "spec",
       [
-        join(root, "S-spec", "S-spec.md"),
-        ["用户故事", "验收合同", "代码", "CONTEXT", "ADR", "验证接缝", "ready_for_tickets"],
+        join(root, "specdev-s-spec", "SKILL.md"),
+        ["用户端到端行为", "验收合同", "代码", "CONTEXT", "ADR", "验证接缝", "ready_for_tickets"],
       ],
     ],
     [
       "tickets",
       [
-        join(root, "T-tickets", "T-tickets.md"),
+        join(root, "specdev-t-tickets", "SKILL.md"),
         ["Prefactor", "垂直切片", "Expand", "与用户核对", "Definition of Ready"],
       ],
     ],
     [
       "goal-plan",
       [
-        join(root, "P-goal-plan", "P-goal-plan.md"),
+        join(root, "specdev-p-goal-plan", "SKILL.md"),
         [
           "Outcome",
           "权威来源",
@@ -1061,7 +845,7 @@ function capabilityChecks(root) {
           "Gate",
           "Wave",
           "lead-directed",
-          "implementation_agent_limit",
+          "concurrent_implementation_limit",
           "candidate-merge",
           "lead-orchestration.md",
           "Definition of Done",
@@ -1071,70 +855,70 @@ function capabilityChecks(root) {
     [
       "implement",
       [
-        join(root, "I-implement", "I-implement.md"),
-        ["codebase-design", "design-it-twice", "TDD", "双轴审查", "Evidence", "parent-candidate", "subagent-delivery", "实现 commit"],
+        join(root, "specdev-i-implement", "SKILL.md"),
+        ["codebase-design", "design-it-twice", "TDD", "双轴审查", "Evidence", "parent-candidate", "共享编排方法", "实现 commit"],
       ],
     ],
     [
       "code-review",
       [
-        join(root, "C-code-review", "C-code-review.md"),
+        join(root, "specdev-c-code-review", "SKILL.md"),
         ["--review-scope", "baseline", "range", "commit", "pr", "no-diff", "固定点", "标准轴", "规范轴", "未合并排名", "reviews/CR-###.md"],
       ],
     ],
     [
       "prototype",
       [
-        join(root, "P-prototype", "P-prototype.md"),
+        join(root, "specdev-p-prototype", "SKILL.md"),
         ["设计定向", "风格", "design-system.md", "comparison", "HTML/CSS/JS", "design-library/INDEX.md"],
       ],
     ],
     [
-      "learn-change",
+      "learn",
       [
-        join(root, "L-learn-change", "L-learn-change.md"),
-        ["开发完成后", "零专业背景", "$ARGUMENTS", "ASCII", "learning/index.md", "{number}_{topic}.md", "{roots.state}/learning/"],
+        join(root, "specdev-l-learn", "SKILL.md"),
+        ["需求参考", "零专业背景", "$ARGUMENTS", "ASCII", "learning-change.md", "learning/index.md", "{number}_{topic}.md", "{roots.state}/learning/"],
       ],
     ],
     [
       "wayfinder",
       [
-        join(root, "W-wayfinder", "W-wayfinder.md"),
-        ["共享地图", "claimed_investigations", "wayfinder:prototype", "wayfinder:grilling", "solution comment", "每个会话"],
+        join(root, "specdev-w-wayfinder", "SKILL.md"),
+        ["共享地图", "调查认领", "wayfinder:prototype", "wayfinder:grilling", "solution comment", "每个会话"],
       ],
     ],
     [
       "architecture-review",
       [
-        join(root, "R-review-architecture", "R-review-architecture.md"),
+        join(root, "specdev-r-review-architecture", "SKILL.md"),
         ["结构性坏味道", "code-judo", "删除测试", "高置信候选", "最佳推荐"],
       ],
     ],
     [
       "architecture-review-rubric",
       [
-        join(root, "R-review-architecture", "review-rubric.md"),
+        join(root, "specdev-r-review-architecture", "references/review-rubric.md"),
         ["删除测试", "文件大小", "高置信候选", "spaghetti growth"],
       ],
     ],
     [
       "archive",
       [
-        join(root, "A-archive-and-consolidate", "A-archive-and-consolidate.md"),
+        join(root, "specdev-a-archive-and-consolidate", "SKILL.md"),
         ["archive-single", "dry-run", "external_action", "publish_action", "consolidate-from-code", "archive-and-consolidate"],
       ],
     ],
     [
       "grill",
       [
-        join(root, "G-grill-with-docs", "G-grill-with-docs.md"),
+        join(root, "specdev-g-grill-with-docs", "SKILL.md"),
         ["完整 frontier", "design-tree.json", "LOG.md", "CONTEXT.md", "ADR.md", "推荐答案", "永久 namespace 对 G 只读"],
       ],
     ],
     [
       "diagnosis",
       [
-        join(root, "D-diagnose-bugs", "D-diagnose-bugs.md"),
+        join(root, "specdev-d-diagnose-bugs", "SKILL.md"),
         ["红灯", "反馈回路", "最小化", "可证伪", "根因", "回归测试"],
       ],
     ],
@@ -1156,35 +940,35 @@ function capabilityChecks(root) {
     "common/rules/codebase-design.md",
     "common/schemas/design-tree.schema.json",
     "common/schemas/wayfinder-ticket.schema.json",
-    "G-grill-with-docs/design-tree-template.json",
-    "W-wayfinder/local-tracker-contract.md",
-    "W-wayfinder/solution-comment-template.md",
+    "specdev-g-grill-with-docs/assets/design-tree-template.json",
+    "specdev-w-wayfinder/references/local-tracker-contract.md",
+    "specdev-w-wayfinder/assets/solution-comment-template.md",
     "common/rules/parent-implementation-orchestration.md",
     "common/schemas/implementation-map.schema.json",
     "common/schemas/implementation-plan.schema.json",
     "common/schemas/capture.schema.json",
-    "T-triage/capture-protocol.md",
-    "T-triage/capture-template.md",
-    "T-triage/issue-record-template.md",
-    "T-triage/tools/capture-status.mjs",
+    "specdev-t-triage/references/capture-protocol.md",
+    "specdev-t-triage/assets/capture-template.md",
+    "specdev-t-triage/assets/issue-record-template.md",
+    "specdev-t-triage/scripts/capture-status.mjs",
   ]) {
     if (!isFile(join(root, required))) errors.push(`missing architecture/wayfinding contract ${required}`);
   }
 
-  const mapTemplate = join(root, "W-wayfinder", "wayfinder-map-template.md");
+  const mapTemplate = join(root, "specdev-w-wayfinder", "assets/wayfinder-map-template.md");
   if (isFile(mapTemplate) && /^## (?:开放 Tickets|调查清单)/m.test(readText(mapTemplate))) {
     errors.push("Wayfinder map template must query open Tickets instead of caching them");
   }
 
-  const goalPlanTemplate = join(root, "P-goal-plan", "goal-plan-template.md");
+  const goalPlanTemplate = join(root, "specdev-p-goal-plan", "assets/goal-plan-template.md");
   if (!isFile(goalPlanTemplate)) {
     errors.push("missing Goal Plan template");
   } else {
     const text = readText(goalPlanTemplate);
     for (const required of [
-      "schema_version: 6",
+      "schema_version: 7",
       "orchestration: lead-directed",
-      "implementation_agent_limit: 3",
+      "concurrent_implementation_limit: 3",
       "integration_attempt_limit: 3",
       "ticket_workspace_policy: current",
       "integration_gate: direct-parent",
@@ -1209,11 +993,11 @@ function selfCheck(root) {
   const errors = [];
   const warnings = [];
 
-  if (!isFile(join(root, "INDEX.md"))) errors.push("missing package INDEX");
+  if (!isFile(join(root, "SKILL.md"))) errors.push("missing domain Skill");
 
   const actualWorks = new Set(
     readdirSync(root, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory() && /^[A-Z]-/.test(entry.name))
+      .filter((entry) => entry.isDirectory() && /^specdev-[a-z]-/.test(entry.name))
       .map((entry) => entry.name),
   );
   const missingWorks = [...EXPECTED_WORKS].filter((name) => !actualWorks.has(name));
@@ -1223,23 +1007,16 @@ function selfCheck(root) {
 
   const ids = [];
   for (const directoryName of [...actualWorks].sort()) {
-    const entry = join(root, directoryName, `${directoryName}.md`);
+    const entry = join(root, directoryName, "SKILL.md");
     if (!isFile(entry)) {
       errors.push(`missing work entry ${toPosix(relative(root, entry))}`);
       continue;
     }
     const { meta } = parseFrontmatter(entry);
-    if (meta.type !== "workflow-entry") {
-      errors.push(`${toPosix(relative(root, entry))}: type must be workflow-entry`);
-    }
-    if (meta.workflow !== "specdev") {
-      errors.push(`${toPosix(relative(root, entry))}: workflow must be specdev`);
-    }
-    if (typeof meta.id !== "string" || !meta.id.startsWith("specdev/")) {
-      errors.push(`${toPosix(relative(root, entry))}: invalid work id`);
-    } else {
-      ids.push(meta.id);
-    }
+    errors.push(...validateSkill(readText(entry),directoryName).map(error=>entry+": "+error));
+    if(meta.metadata?.["speculo-kind"]!=="work-skill" || meta.metadata?.["speculo-domain"]!=="specdev")errors.push(entry+": invalid Work metadata");
+    const id=meta.metadata?.["speculo-id"];
+    if(typeof id!=="string"||!id.startsWith("specdev/"))errors.push(entry+": invalid work id");else ids.push(id);
   }
   if (ids.length !== new Set(ids).size) errors.push("duplicate workflow entry id");
 
@@ -1377,7 +1154,7 @@ function validateSource(path, expectedChange, errors) {
   return { path, meta, body };
 }
 
-function validateTriage(path, expectedChange, errors, historical = false) {
+function validateTriage(path, expectedChange, errors) {
   if (!isFile(path)) {
     errors.push("missing triage artifact");
     return null;
@@ -1398,8 +1175,8 @@ function validateTriage(path, expectedChange, errors, historical = false) {
   ];
   const missing = required.filter((key) => !(key in meta));
   if (missing.length) errors.push(`triage.md: missing keys ${JSON.stringify(missing)}`);
-  if ((meta.schema_version !== 2 && !(historical && meta.schema_version === 1)) || meta.artifact !== "triage") {
-    errors.push("triage.md: artifact/schema_version must be triage/2; v1 is historical read-only");
+  if (meta.schema_version !== 2 || meta.artifact !== "triage") {
+    errors.push("triage.md: artifact/schema_version must be triage/2");
   }
   if (meta.schema_version === 2) {
     if (!["needs-triage", "needs-info", "ready-for-agent", "ready-for-human", "wontfix"].includes(meta.disposition)) errors.push("triage.md: invalid disposition");
@@ -1710,10 +1487,12 @@ function validateReviews(change, required, errors) {
   return paths;
 }
 
-function validatePrototypes(change, required, errors) {
+function validatePrototypes(change, required, errors, prototypeId = null, consumingDesign = false, context = null) {
   const root = join(change, "prototypes");
+  const changeDesign = isFile(join(change, "DESIGN.md")) ? parseFrontmatter(join(change, "DESIGN.md")).meta : null;
+  const boundId = changeDesign?.prototype_ref?.id;
   if (!isDirectory(root)) {
-    if (required) errors.push("prototype stage requires a prototypes/UI-NNN/design-system.md artifact");
+    if (required || boundId) errors.push("prototype stage requires a prototypes/UI-NNN/design-system.md artifact");
     return [];
   }
 
@@ -1721,16 +1500,21 @@ function validatePrototypes(change, required, errors) {
     dirname(fileURLToPath(import.meta.url)),
     "..",
     "..",
-    "P-prototype",
-    "tools",
+    "specdev-p-prototype",
+    "scripts",
     "validate-design-package.mjs",
   );
   const paths = [];
   let readyCount = 0;
+  const candidates = readdirSync(root).filter(name => /^(?:UI|LOGIC)-\d{3,}$/.test(name));
+  if (required && !prototypeId && candidates.length !== 1) errors.push("prototype stage requires --prototype-id when multiple packages exist");
+  const selectedId = prototypeId ?? (required && candidates.length === 1 ? candidates[0] : !required ? boundId : null);
+  if (selectedId && !candidates.includes(selectedId)) errors.push(`prototype not found: ${selectedId}`);
 
   for (const entry of readdirSync(root, { withFileTypes: true })) {
     const entryPath = join(root, entry.name);
     const label = toPosix(relative(change, entryPath));
+    if (selectedId && entry.name !== selectedId) continue;
     if (entry.isSymbolicLink()) {
       errors.push(`${label}: prototype design directories and files must not be symlinks`);
       continue;
@@ -1758,9 +1542,10 @@ function validatePrototypes(change, required, errors) {
     }
     paths.push(designPath);
     const { meta } = parseFrontmatter(designPath);
+    if (consumingDesign && entry.name === boundId && meta.status !== "ready") errors.push(`${label}: bound UI prototype must be ready before downstream consumption`);
     if (meta.status === "ready") readyCount += 1;
     try {
-      execFileSync(process.execPath, [validator, designPath], {
+      execFileSync(process.execPath, [validator, ...contextArguments(context), ...(consumingDesign && entry.name === boundId ? ["--check-ready"] : []), designPath], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "pipe"],
       });
@@ -1774,13 +1559,14 @@ function validatePrototypes(change, required, errors) {
     }
   }
 
-  const obsoleteRecords = walk(root).filter(
+  const scanRoot = selectedId && isDirectory(join(root, selectedId)) ? join(root, selectedId) : root;
+  const obsoleteRecords = walk(scanRoot).filter(
     (path) => isFile(path) && basename(path) === "record.md",
   );
   for (const path of obsoleteRecords) {
     errors.push(`${toPosix(relative(change, path))}: obsolete prototype record is forbidden; use UI-NNN/design-system.md`);
   }
-  const discoveredDesigns = walk(root).filter(
+  const discoveredDesigns = walk(scanRoot).filter(
     (path) => isFile(path) && basename(path) === "design-system.md",
   );
   for (const path of discoveredDesigns) {
@@ -1789,7 +1575,7 @@ function validatePrototypes(change, required, errors) {
     }
   }
   if (required && readyCount === 0) {
-    errors.push("prototype stage requires at least one ready UI or logic design package");
+    errors.push("prototype stage requires the selected ready UI or logic design package");
   }
   return paths;
 }
@@ -1800,7 +1586,7 @@ function validateChangeLearning(change, required, errors) {
   const diagramName = /^\d{2,}_[\p{L}\p{N}_-]+\.md$/u;
 
   if (!existsSync(learningRoot)) {
-    if (required) errors.push("learn-change stage requires learning/index.md");
+    if (required) errors.push("learn stage requires learning/index.md");
     return null;
   }
   if (lstatSync(learningRoot).isSymbolicLink() || !isDirectory(learningRoot)) {
@@ -1809,22 +1595,27 @@ function validateChangeLearning(change, required, errors) {
   }
 
   const diagramFiles = [];
+  const diagramNumbers = new Set();
   for (const entry of readdirSync(learningRoot, { withFileTypes: true })) {
     if (entry.isSymbolicLink()) {
       errors.push(`learning/${entry.name}: learning artifacts must not be symlinks`);
     } else if (entry.isFile() && diagramName.test(entry.name)) {
       diagramFiles.push(entry.name);
+      const number = Number(entry.name.split("_")[0]);
+      if (diagramNumbers.has(number)) errors.push(`learning/${entry.name}: duplicate diagram number ${number}`);
+      diagramNumbers.add(number);
     }
   }
   diagramFiles.sort();
 
   if (!isFile(indexPath)) {
-    errors.push("learn-change stage requires learning/index.md");
+    errors.push("learn stage requires learning/index.md");
     return null;
   }
 
   const index = readText(indexPath);
-  if (!index.includes("# Change 学习图解索引")) {
+  // Historical titles remain readable without rewriting existing learning records.
+  if (!/^# (?:Change )?学习图解索引\s*$/m.test(index)) {
     errors.push("learning/index.md: missing index heading");
   }
   const entries = Array.from(
@@ -2076,7 +1867,7 @@ function validateGoalPlan(path, errors) {
     "modes",
     "orchestration",
       "lead",
-      "implementation_agent_limit",
+      "concurrent_implementation_limit",
       "integration_attempt_limit",
     "ticket_workspace_policy",
     "integration_gate",
@@ -2100,8 +1891,8 @@ function validateGoalPlan(path, errors) {
   if (typeof meta.lead !== "string" || !meta.lead.trim()) {
     errors.push(`${basename(path)}: lead must be a non-empty recoverable locator`);
   }
-  if (!Number.isInteger(meta.implementation_agent_limit) || meta.implementation_agent_limit < 1) {
-    errors.push(`${basename(path)}: implementation_agent_limit must be a positive integer`);
+  if (!Number.isInteger(meta.concurrent_implementation_limit) || meta.concurrent_implementation_limit < 1) {
+    errors.push(`${basename(path)}: concurrent_implementation_limit must be a positive integer`);
   }
   if (!Number.isInteger(meta.integration_attempt_limit) || meta.integration_attempt_limit < 1) {
     errors.push(`${basename(path)}: integration_attempt_limit must be a positive integer`);
@@ -2154,25 +1945,9 @@ function validateGoalPlan(path, errors) {
   return { path, meta, body };
 }
 
-function validateGoalPlanRuntimeLimits(path, change, goalPlan, errors, repoRoot = null) {
+function validateGoalPlanRuntimeLimits(path, change, goalPlan, errors, repoRoot = null, options = {}) {
   if (!goalPlan) return;
-  const config = findSpecdevConfig(change, repoRoot);
-  if (!config) {
-    errors.push(`${basename(path)}: SpecDev config.json is required to validate execution limits`);
-    return;
-  }
-  const configuredAgents = positiveConfigLimit(config, "max_implementation_agents", 0);
-  const configuredAttempts = positiveConfigLimit(config, "max_integration_attempts", 0);
-  if (config.schema_version !== CONFIG_SCHEMA_VERSION || configuredAgents === 0 || configuredAttempts === 0) {
-    errors.push(`${basename(path)}: SpecDev config.json must use schema v${CONFIG_SCHEMA_VERSION} with positive execution limits`);
-    return;
-  }
-  if (goalPlan.meta.implementation_agent_limit > configuredAgents) {
-    errors.push(`${basename(path)}: implementation_agent_limit ${goalPlan.meta.implementation_agent_limit} exceeds config max_implementation_agents ${configuredAgents}`);
-  }
-  if (goalPlan.meta.integration_attempt_limit > configuredAttempts) {
-    errors.push(`${basename(path)}: integration_attempt_limit ${goalPlan.meta.integration_attempt_limit} exceeds config max_integration_attempts ${configuredAttempts}`);
-  }
+  errors.push(...validateExecutionPolicy(goalPlan, findSpecdevConfig(change, repoRoot, options)).map(error => `${basename(path)}: ${error}`));
 }
 
 function validateDesignTree(path, change, errors) {
@@ -2439,61 +2214,24 @@ function validateTicket(path, errors) {
   return { path, meta, body };
 }
 
-function validateChangeStatus(path, expectedChange, errors) {
-  if (!isFile(path)) {
-    errors.push("missing change status artifact");
-    return null;
-  }
+function validateChangeExecution(change, errors, context) {
+  const path = join(change, "evidence"), expectedChange = basename(change);
   let data;
   try {
-    data = JSON.parse(readText(path));
-  } catch (error) {
-    errors.push(`${basename(path)}: invalid JSON: ${error.message}`);
-    return null;
-  }
-  const required = [
-    "schema_version",
-    "artifact",
-    "change",
-    "change_status",
-    "current_work",
-    "works_run",
-    "claimed_investigations",
-    "execution_authorization",
-    "leadership",
-    "created_at",
-    "updated_at",
-    "completed_at",
-    "archived",
-    "archive_path",
-    "blockers",
-    "deviations",
-    "worktrees",
-  ];
-  const missing = required.filter((key) => !(key in data));
-  if (missing.length) errors.push(`${basename(path)}: missing keys ${JSON.stringify(missing.sort())}`);
-  const unexpected = Object.keys(data).filter((key) => !required.includes(key));
-  if (unexpected.length) errors.push(`${basename(path)}: unexpected keys ${JSON.stringify(unexpected.sort())}`);
-  if (data.schema_version !== CHANGE_STATUS_SCHEMA_VERSION || data.artifact !== "change-status") {
-    errors.push(`${basename(path)}: artifact/schema_version must be change-status/${CHANGE_STATUS_SCHEMA_VERSION}`);
-  }
-  if (data.change !== expectedChange) {
-    errors.push(`${basename(path)}: change must equal directory name ${expectedChange}`);
-  }
-  if (!new Set(["active", "blocked", "completed", "archived"]).has(data.change_status)) {
-    errors.push(`${basename(path)}: invalid change_status ${data.change_status}`);
-  }
-  if (!Array.isArray(data.blockers) || !Array.isArray(data.deviations) || !Array.isArray(data.worktrees)) {
-    errors.push(`${basename(path)}: blockers, deviations, and worktrees must be arrays`);
-  }
+    const facts = runtime.readChangeFactsSync(context, basename(change));
+    if (facts.location.root !== resolve(change)) throw new Error('change identity does not match requested location');
+    data = { ...facts, worktrees:readChangeExecution(change) };
+  } catch (error) { errors.push(`${change}: ${error.message}`); return null; }
   const seenWorktreeTickets = new Set();
   for (const worktree of Array.isArray(data.worktrees) ? data.worktrees : []) {
     if (!worktree || typeof worktree !== "object" || Array.isArray(worktree)) {
       errors.push(`${basename(path)}: invalid worktree entry`);
       continue;
     }
+    const direct = worktree.purpose === "direct-spec";
+    const unit = direct ? "direct-spec" : worktree.ticket_id;
     const requiredWorktreeKeys = [
-      "ticket_id",
+      ...(direct ? ["purpose", "change", "integration_attempt_limit"] : ["ticket_id"]),
       "owner",
       "implementation_owner",
       "integration_owner",
@@ -2514,14 +2252,24 @@ function validateChangeStatus(path, expectedChange, errors) {
     }
     const unexpectedWorktreeKeys = Object.keys(worktree).filter((key) => !requiredWorktreeKeys.includes(key));
     if (unexpectedWorktreeKeys.length) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} has unexpected keys ${JSON.stringify(unexpectedWorktreeKeys.sort())}`);
+      errors.push(`${basename(path)}: worktree ${unit} has unexpected keys ${JSON.stringify(unexpectedWorktreeKeys.sort())}`);
     }
-    if (!/^T-[0-9]{2,}$/.test(String(worktree.ticket_id))) {
-      errors.push(`${basename(path)}: invalid worktree ticket_id ${worktree.ticket_id}`);
-    } else if (seenWorktreeTickets.has(worktree.ticket_id)) {
-      errors.push(`${basename(path)}: duplicate worktree for ${worktree.ticket_id}`);
-    }
-    seenWorktreeTickets.add(worktree.ticket_id);
+    if (direct) {
+      if (worktree.change !== expectedChange) errors.push("Direct Spec execution belongs to another change");
+      try {
+        if (readChangeOwner(context, expectedChange).owner !== worktree.owner) errors.push("Direct Spec execution owner differs from original Lead");
+      } catch (error) { errors.push(error.message); }
+      if (!Number.isInteger(worktree.integration_attempt_limit) || worktree.integration_attempt_limit < 1) errors.push("Direct Spec requires a positive integration_attempt_limit");
+      if (worktree.integration?.attempts > worktree.integration_attempt_limit) errors.push("Direct Spec integration attempts exceed integration_attempt_limit");
+      if (worktree.integration_owner !== worktree.owner) errors.push("Direct Spec integration owner must be Lead");
+      if (worktree.status === "cancelled" && data.outcome !== "cancelled") errors.push("cancelled Direct Spec execution requires the original whole-change cancellation");
+      if (worktree.workspace_ref !== "current" && worktree.branch !== `speculo/${expectedChange}/direct-spec`) errors.push("Direct Spec source branch must match its change");
+    } else if (!/^T-[0-9]{2,}$/.test(String(unit))) {
+      errors.push(`${basename(path)}: invalid worktree ticket_id ${unit}`);
+    } else if (seenWorktreeTickets.has(unit)) {
+      errors.push(`${basename(path)}: duplicate worktree for ${unit}`);
+    }
+    seenWorktreeTickets.add(unit);
     const ref = worktree.workspace_ref;
     if (
       typeof ref !== "string" ||
@@ -2531,20 +2279,20 @@ function validateChangeStatus(path, expectedChange, errors) {
       errors.push(`${basename(path)}: workspace_ref must be a portable non-absolute locator`);
       continue;
     }
-    if (!VALID_WORKTREE_STATUS.has(worktree.status)) {
+    if (!VALID_WORKTREE_STATUS.has(worktree.status) && !(direct && worktree.status === "cancelled")) {
       errors.push(`${basename(path)}: invalid worktree status ${worktree.status}`);
     }
     const currentWorkspace = ref === "current";
     if (worktree.provider !== "git") {
-      errors.push(`${basename(path)}: Ticket worktree ${worktree.ticket_id} provider must be git`);
+      errors.push(`${basename(path)}: Ticket worktree ${unit} provider must be git`);
     }
-    const expectedRef = `specdev-worktree/${expectedChange}/${worktree.ticket_id}`;
+    const expectedRef = `specdev-worktree/${expectedChange}/${unit}`;
     if (!currentWorkspace && ref !== expectedRef) {
       errors.push(`${basename(path)}: git workspace_ref must equal ${expectedRef}`);
     }
 
     if ("terminal_action" in worktree) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} obsolete terminal_action is not allowed`);
+      errors.push(`${basename(path)}: worktree ${unit} obsolete terminal_action is not allowed`);
     }
     const requiredIntegrationKeys = [
       "owner",
@@ -2556,35 +2304,35 @@ function validateChangeStatus(path, expectedChange, errors) {
     ];
     const missingIntegrationKeys = requiredIntegrationKeys.filter((key) => !(key in worktree));
     if (missingIntegrationKeys.length) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} integration contract missing ${JSON.stringify(missingIntegrationKeys)}`);
+      errors.push(`${basename(path)}: worktree ${unit} integration contract missing ${JSON.stringify(missingIntegrationKeys)}`);
       continue;
     }
     for (const key of ["owner", "implementation_owner", "integration_owner", "base_sha", "parent_branch", "branch", "updated_at"]) {
       if (typeof worktree[key] !== "string" || !worktree[key].trim()) {
-        errors.push(`${basename(path)}: worktree ${worktree.ticket_id} ${key} is required`);
+        errors.push(`${basename(path)}: worktree ${unit} ${key} is required`);
       }
     }
     if (typeof worktree.parent_branch !== "string" || !worktree.parent_branch.trim()) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} parent_branch is required`);
+      errors.push(`${basename(path)}: worktree ${unit} parent_branch is required`);
     } else if (currentWorkspace && worktree.parent_branch !== worktree.branch) {
-      errors.push(`${basename(path)}: current workspace ${worktree.ticket_id} branch must equal parent_branch`);
+      errors.push(`${basename(path)}: current workspace ${unit} branch must equal parent_branch`);
     } else if (!currentWorkspace && worktree.parent_branch === worktree.branch) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} parent_branch must differ from branch`);
+      errors.push(`${basename(path)}: worktree ${unit} parent_branch must differ from branch`);
     }
 
     const sourceRequired = new Set(["review", "integrating", "integrated", "removed"]).has(worktree.status);
     if (sourceRequired && (typeof worktree.source_checkpoint !== "string" || !worktree.source_checkpoint.trim())) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} ${worktree.status} requires source_checkpoint`);
+      errors.push(`${basename(path)}: worktree ${unit} ${worktree.status} requires source_checkpoint`);
     } else if (
       worktree.source_checkpoint !== null &&
       (typeof worktree.source_checkpoint !== "string" || !worktree.source_checkpoint.trim())
     ) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} source_checkpoint must be null or non-empty`);
+      errors.push(`${basename(path)}: worktree ${unit} source_checkpoint must be null or non-empty`);
     }
 
     const integration = worktree.integration;
     if (!integration || typeof integration !== "object" || Array.isArray(integration)) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} integration must be an object`);
+      errors.push(`${basename(path)}: worktree ${unit} integration must be an object`);
       continue;
     }
     const requiredResultKeys = [
@@ -2608,49 +2356,48 @@ function validateChangeStatus(path, expectedChange, errors) {
     ];
     const missingResultKeys = requiredResultKeys.filter((key) => !(key in integration));
     if (missingResultKeys.length) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} integration missing ${JSON.stringify(missingResultKeys)}`);
+      errors.push(`${basename(path)}: worktree ${unit} integration missing ${JSON.stringify(missingResultKeys)}`);
     }
     const unexpectedResultKeys = Object.keys(integration).filter((key) => !requiredResultKeys.includes(key));
     if (unexpectedResultKeys.length) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} integration has unexpected keys ${JSON.stringify(unexpectedResultKeys.sort())}`);
+      errors.push(`${basename(path)}: worktree ${unit} integration has unexpected keys ${JSON.stringify(unexpectedResultKeys.sort())}`);
     }
     if (!VALID_INTEGRATION_STATUS.has(integration.status)) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} has invalid integration status ${integration.status}`);
+      errors.push(`${basename(path)}: worktree ${unit} has invalid integration status ${integration.status}`);
     }
     if (!VALID_INTEGRATION_METHOD.has(integration.method)) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} has invalid integration method ${integration.method}`);
+      errors.push(`${basename(path)}: worktree ${unit} has invalid integration method ${integration.method}`);
     }
     if (!VALID_INTEGRATION_VERIFICATION.has(integration.verification)) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} has invalid integration verification ${integration.verification}`);
+      errors.push(`${basename(path)}: worktree ${unit} has invalid integration verification ${integration.verification}`);
     }
     if (!Array.isArray(integration.conflict_paths)) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} conflict_paths must be an array`);
+      errors.push(`${basename(path)}: worktree ${unit} conflict_paths must be an array`);
     }
     if (!Number.isInteger(integration.attempts) || integration.attempts < 0) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} attempts must be a non-negative integer`);
+      errors.push(`${basename(path)}: worktree ${unit} attempts must be a non-negative integer`);
     }
-    if (
-      typeof integration.evidence !== "string" ||
-      !/^<Path>\{roots\.state\}\/specdev\/changes\/[^<]+\/evidence\/T-[0-9]{2,}\.md<\/Path>$/.test(integration.evidence)
-    ) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} integration evidence must be a rooted Ticket Evidence path`);
+    const expectedEvidence = `<Path>{roots.state}/specdev/changes/${expectedChange}/evidence/${unit}.md</Path>`;
+    if (direct ? integration.evidence !== expectedEvidence : typeof integration.evidence !== "string" || !/^<Path>\{roots\.state\}\/specdev\/changes\/[^<]+\/evidence\/T-[0-9]{2,}\.md<\/Path>$/.test(integration.evidence)) {
+      errors.push(`${basename(path)}: worktree ${unit} integration evidence must be its rooted Evidence path: ${expectedEvidence}`);
     }
     if (!new Set(["pending", "applying", "applied", "failed", "stale"]).has(integration.promotion_status)) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} has invalid promotion_status ${integration.promotion_status}`);
+      errors.push(`${basename(path)}: worktree ${unit} has invalid promotion_status ${integration.promotion_status}`);
     }
     for (const [name, suite] of [["full_suite", integration.full_suite], ["e2e", integration.e2e]]) {
       if (!suite || typeof suite !== "object" || Array.isArray(suite) || typeof suite.required !== "boolean" || !VALID_E2E_STATUS.has(suite.status)) {
-        errors.push(`${basename(path)}: worktree ${worktree.ticket_id} ${name} contract is invalid`);
+        errors.push(`${basename(path)}: worktree ${unit} ${name} contract is invalid`);
         continue;
       }
       const unexpectedSuiteKeys = Object.keys(suite).filter((key) => !new Set(["required", "status", "reason", "evidence"]).has(key));
-      if (unexpectedSuiteKeys.length) errors.push(`${basename(path)}: worktree ${worktree.ticket_id} ${name} has unexpected keys ${JSON.stringify(unexpectedSuiteKeys.sort())}`);
+      if (unexpectedSuiteKeys.length) errors.push(`${basename(path)}: worktree ${unit} ${name} has unexpected keys ${JSON.stringify(unexpectedSuiteKeys.sort())}`);
       if (suite.required === false && (suite.status !== "not-required" || typeof suite.reason !== "string" || !suite.reason.trim())) {
-        errors.push(`${basename(path)}: worktree ${worktree.ticket_id} non-required ${name} needs not-required status and reason`);
+        errors.push(`${basename(path)}: worktree ${unit} non-required ${name} needs not-required status and reason`);
       }
       if (suite.required === true && suite.status === "not-required") {
-        errors.push(`${basename(path)}: worktree ${worktree.ticket_id} required ${name} cannot be not-required`);
+        errors.push(`${basename(path)}: worktree ${unit} required ${name} cannot be not-required`);
       }
+      if (direct && suite.required === true && suite.status === "passed" && (typeof suite.evidence !== "string" || !suite.evidence.trim())) errors.push(`Direct Spec passed ${name} requires actual evidence`);
     }
     const e2e = integration.e2e;
     if (
@@ -2660,65 +2407,65 @@ function validateChangeStatus(path, expectedChange, errors) {
       typeof e2e.required !== "boolean" ||
       !VALID_E2E_STATUS.has(e2e.status)
     ) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} integration e2e contract is invalid`);
+      errors.push(`${basename(path)}: worktree ${unit} integration e2e contract is invalid`);
     } else {
       const unexpectedE2eKeys = Object.keys(e2e).filter((key) => !new Set(["required", "status", "reason", "evidence"]).has(key));
       if (unexpectedE2eKeys.length) {
-        errors.push(`${basename(path)}: worktree ${worktree.ticket_id} integration e2e has unexpected keys ${JSON.stringify(unexpectedE2eKeys.sort())}`);
+        errors.push(`${basename(path)}: worktree ${unit} integration e2e has unexpected keys ${JSON.stringify(unexpectedE2eKeys.sort())}`);
       }
       if (e2e.required === false && e2e.status !== "not-required") {
-        errors.push(`${basename(path)}: worktree ${worktree.ticket_id} non-required E2E must use status=not-required`);
+        errors.push(`${basename(path)}: worktree ${unit} non-required E2E must use status=not-required`);
       }
       if (e2e.required === true && e2e.status === "not-required") {
-        errors.push(`${basename(path)}: worktree ${worktree.ticket_id} required E2E cannot be not-required`);
+        errors.push(`${basename(path)}: worktree ${unit} required E2E cannot be not-required`);
       }
       if (
         e2e.required === true &&
         e2e.status === "passed" &&
         (typeof e2e.evidence !== "string" || !e2e.evidence.trim())
       ) {
-        errors.push(`${basename(path)}: worktree ${worktree.ticket_id} passed required E2E needs evidence`);
+        errors.push(`${basename(path)}: worktree ${unit} passed required E2E needs evidence`);
       }
     }
     const integrationLifecycleActive = new Set(["integrating", "integrated", "removed"]).has(worktree.status);
     if (integrationLifecycleActive) {
       if (typeof integration.parent_before_sha !== "string" || !integration.parent_before_sha.trim()) {
-        errors.push(`${basename(path)}: worktree ${worktree.ticket_id} ${worktree.status} requires parent_before_sha`);
+        errors.push(`${basename(path)}: worktree ${unit} ${worktree.status} requires parent_before_sha`);
       }
       if (typeof integration.source_sha !== "string" || !integration.source_sha.trim()) {
-        errors.push(`${basename(path)}: worktree ${worktree.ticket_id} ${worktree.status} requires source_sha`);
+        errors.push(`${basename(path)}: worktree ${unit} ${worktree.status} requires source_sha`);
       } else if (integration.source_sha !== worktree.source_checkpoint) {
-        errors.push(`${basename(path)}: worktree ${worktree.ticket_id} source_sha must equal source_checkpoint`);
+        errors.push(`${basename(path)}: worktree ${unit} source_sha must equal source_checkpoint`);
       }
       if (currentWorkspace) {
         if (integration.candidate_sha !== null || integration.candidate_tree_sha !== null || integration.candidate_branch !== null || integration.candidate_workspace_ref !== null) {
-          errors.push(`${basename(path)}: current workspace ${worktree.ticket_id} cannot record candidate workspace fields`);
+          errors.push(`${basename(path)}: current workspace ${unit} cannot record candidate workspace fields`);
         }
         if (integration.method !== "direct-parent") {
-          errors.push(`${basename(path)}: current workspace ${worktree.ticket_id} requires integration.method=direct-parent`);
+          errors.push(`${basename(path)}: current workspace ${unit} requires integration.method=direct-parent`);
         }
       } else {
         if (typeof integration.candidate_sha !== "string" || !integration.candidate_sha.trim()) {
-          errors.push(`${basename(path)}: worktree ${worktree.ticket_id} ${worktree.status} requires candidate_sha`);
+          errors.push(`${basename(path)}: worktree ${unit} ${worktree.status} requires candidate_sha`);
         }
-        const expectedCandidateBranch = `speculo/integration/${expectedChange}/${worktree.ticket_id}`;
+        const expectedCandidateBranch = `speculo/integration/${expectedChange}/${unit}`;
         if (integration.candidate_branch !== expectedCandidateBranch) {
-          errors.push(`${basename(path)}: worktree ${worktree.ticket_id} candidate_branch must equal ${expectedCandidateBranch}`);
+          errors.push(`${basename(path)}: worktree ${unit} candidate_branch must equal ${expectedCandidateBranch}`);
         }
-        const expectedCandidateRef = `specdev-worktree/.integration/${expectedChange}/${worktree.ticket_id}`;
+        const expectedCandidateRef = `specdev-worktree/.integration/${expectedChange}/${unit}`;
         if (integration.candidate_workspace_ref !== expectedCandidateRef) {
-          errors.push(`${basename(path)}: worktree ${worktree.ticket_id} candidate_workspace_ref must equal ${expectedCandidateRef}`);
+          errors.push(`${basename(path)}: worktree ${unit} candidate_workspace_ref must equal ${expectedCandidateRef}`);
         }
         if (!new Set(["fast-forward", "merge-commit"]).has(integration.method)) {
-          errors.push(`${basename(path)}: worktree ${worktree.ticket_id} ${worktree.status} requires an integration method`);
+          errors.push(`${basename(path)}: worktree ${unit} ${worktree.status} requires an integration method`);
         }
       }
     if (!Number.isInteger(integration.attempts) || integration.attempts < 1) {
-      errors.push(`${basename(path)}: worktree ${worktree.ticket_id} ${worktree.status} requires attempts >= 1`);
+      errors.push(`${basename(path)}: worktree ${unit} ${worktree.status} requires attempts >= 1`);
     }
     }
     if (worktree.status === "integrating" && integration.status !== "candidate") {
-      errors.push(`${basename(path)}: integrating worktree ${worktree.ticket_id} requires integration.status=candidate`);
+      errors.push(`${basename(path)}: integrating worktree ${unit} requires integration.status=candidate`);
     }
     if (new Set(["integrated", "removed"]).has(worktree.status)) {
       if (
@@ -2728,49 +2475,41 @@ function validateChangeStatus(path, expectedChange, errors) {
         typeof integration.result_sha !== "string" ||
         !integration.result_sha.trim() ||
         (currentWorkspace ? integration.result_sha !== worktree.source_checkpoint : integration.result_sha !== integration.candidate_sha) ||
+        (direct && (integration.promotion_status !== "applied" || !new Set(["not-required", "passed"]).has(integration.full_suite?.status))) ||
         !e2e ||
         !new Set(["not-required", "passed"]).has(e2e.status)
       ) {
-        errors.push(`${basename(path)}: ${worktree.status} worktree ${worktree.ticket_id} requires passed candidate/result/E2E state`);
+        errors.push(`${basename(path)}: ${worktree.status} worktree ${unit} requires passed candidate/result/E2E state`);
       }
       if (currentWorkspace && integration.method === "direct-parent") {
         if (integration.candidate_sha !== null || integration.candidate_tree_sha !== null || integration.candidate_branch !== null || integration.candidate_workspace_ref !== null) {
-          errors.push(`${basename(path)}: current workspace ${worktree.ticket_id} direct-parent cannot record candidate fields`);
+          errors.push(`${basename(path)}: current workspace ${unit} direct-parent cannot record candidate fields`);
         }
         if (integration.result_sha !== worktree.source_checkpoint) {
-          errors.push(`${basename(path)}: current workspace ${worktree.status} ${worktree.ticket_id} result_sha must equal source_checkpoint`);
+          errors.push(`${basename(path)}: current workspace ${worktree.status} ${unit} result_sha must equal source_checkpoint`);
         }
       } else if (integration.method === "fast-forward") {
         if (integration.candidate_sha !== worktree.source_checkpoint) {
-          errors.push(`${basename(path)}: ${worktree.status} worktree ${worktree.ticket_id} fast-forward candidate/result must equal source_checkpoint`);
+          errors.push(`${basename(path)}: ${worktree.status} worktree ${unit} fast-forward candidate/result must equal source_checkpoint`);
         }
         if (Array.isArray(integration.conflict_paths) && integration.conflict_paths.length > 0) {
-          errors.push(`${basename(path)}: ${worktree.status} worktree ${worktree.ticket_id} fast-forward cannot record conflict_paths`);
+          errors.push(`${basename(path)}: ${worktree.status} worktree ${unit} fast-forward cannot record conflict_paths`);
         }
       } else if (
         integration.method === "merge-commit" &&
         typeof integration.candidate_sha === "string" &&
         (integration.candidate_sha === worktree.source_checkpoint || integration.candidate_sha === integration.parent_before_sha)
       ) {
-        errors.push(`${basename(path)}: ${worktree.status} worktree ${worktree.ticket_id} merge-commit candidate must be a distinct checkpoint`);
+        errors.push(`${basename(path)}: ${worktree.status} worktree ${unit} merge-commit candidate must be a distinct checkpoint`);
       }
     }
   }
-  if (data.change_status === "archived") {
-    if (data.archived !== true) errors.push(`${basename(path)}: archived status requires archived=true`);
-    const inner = typeof data.archive_path === "string" ? stripPathTag(data.archive_path) : null;
-    if (inner === null || !inner.startsWith(`${STATE_PREFIX}archive/`)) {
-      errors.push(`${basename(path)}: archived status requires a rooted archive_path`);
-    }
-  } else if (data.archived === true) {
-    errors.push(`${basename(path)}: archived=true conflicts with change_status=${data.change_status}`);
-  }
   return data;
 }
 
 function validateCurrentWorkspaceExecution(changeStatus, goalPlan, errors) {
-  if (goalPlan?.meta.ticket_workspace_policy !== "current") return;
-  const entries = Array.isArray(changeStatus?.worktrees) ? changeStatus.worktrees : [];
+  const allEntries = Array.isArray(changeStatus?.worktrees) ? changeStatus.worktrees : [];
+  const entries = goalPlan?.meta.ticket_workspace_policy === "current" ? allEntries : allEntries.filter(entry => entry.workspace_ref === "current");
   const active = [];
   for (const worktree of entries) {
     if (worktree.workspace_ref !== "current") {
@@ -2780,7 +2519,7 @@ function validateCurrentWorkspaceExecution(changeStatus, goalPlan, errors) {
       errors.push(`${worktree.ticket_id}: current workspace execution must commit directly on parent_branch`);
     }
     if (new Set(["active", "review", "integrating", "blocked"]).has(worktree.status)) {
-      active.push(worktree.ticket_id);
+      active.push(worktree.ticket_id ?? worktree.purpose);
     }
     const integration = worktree.integration;
     if (integration && typeof integration === "object" && !Array.isArray(integration)) {
@@ -2819,7 +2558,7 @@ function gitSucceeds(repoRoot, args) {
 }
 
 function validateGitEvidence(repoRoot, changeStatus, errors) {
-  if (!repoRoot) return;
+  if (!repoRoot || !changeStatus?.worktrees?.length) return;
   const resolvedRoot = resolve(repoRoot);
   if (gitOutput(resolvedRoot, ["rev-parse", "--is-inside-work-tree"]) !== "true") {
     errors.push(`--repo is not a Git worktree: ${resolvedRoot}`);
@@ -2827,7 +2566,7 @@ function validateGitEvidence(repoRoot, changeStatus, errors) {
   }
   const currentBranch = gitOutput(resolvedRoot, ["branch", "--show-current"]);
   for (const worktree of Array.isArray(changeStatus?.worktrees) ? changeStatus.worktrees : []) {
-    const label = String(worktree.ticket_id ?? "worktree");
+    const label = String(worktree.ticket_id ?? worktree.purpose ?? "worktree");
     for (const [name, sha] of [
       ["base_sha", worktree.base_sha],
       ["source_checkpoint", worktree.source_checkpoint],
@@ -2851,13 +2590,56 @@ function validateGitEvidence(repoRoot, changeStatus, errors) {
     } else if (worktree.integration?.source_sha && worktree.base_sha && !gitSucceeds(resolvedRoot, ["merge-base", "--is-ancestor", worktree.base_sha, worktree.integration.source_sha])) {
       errors.push(`${label}: source_sha must descend from base_sha`);
     }
+    if (worktree.workspace_ref !== "current" && new Set(["active","review","integrating","blocked"]).has(worktree.status)) {
+      try {
+        const source = runtime.safeWorkPathSync(resolvedRoot,worktree.workspace_ref,{mustExist:true,type:"directory"});
+        const common = gitOutput(resolvedRoot,["rev-parse","--path-format=absolute","--git-common-dir"]);
+        if (gitOutput(source,["rev-parse","--path-format=absolute","--git-common-dir"]) !== common || gitOutput(source,["branch","--show-current"]) !== worktree.branch) errors.push(`${label}: source workspace must be a real isolated worktree of the recorded repository and branch`);
+      } catch(error) { errors.push(`${label}: actual source isolation is missing: ${error.message}`); }
+    }
+    if (worktree.status === "integrating" && worktree.workspace_ref !== "current") {
+      try {
+        const candidate = runtime.safeWorkPathSync(resolvedRoot,worktree.integration.candidate_workspace_ref,{mustExist:true,type:"directory"});
+        if (gitOutput(candidate,["rev-parse","HEAD"]) !== worktree.integration.candidate_sha || gitOutput(candidate,["rev-parse","HEAD^{tree}"]) !== worktree.integration.candidate_tree_sha) errors.push(`${label}: actual candidate workspace differs from the recorded checkpoint/tree`);
+      } catch(error) { errors.push(`${label}: actual candidate isolation is missing: ${error.message}`); }
+    }
+    if (worktree.purpose === "direct-spec") {
+      const integration = worktree.integration;
+      if (worktree.source_checkpoint && gitOutput(resolvedRoot, ["rev-parse", worktree.branch]) !== worktree.source_checkpoint && worktree.status !== "removed") errors.push(`${label}: source branch tip differs from source_checkpoint`);
+      if (worktree.source_checkpoint && !gitSucceeds(resolvedRoot, ["merge-base", "--is-ancestor", worktree.base_sha, worktree.source_checkpoint])) errors.push(`${label}: source_checkpoint must descend from base_sha`);
+      if (worktree.workspace_ref !== "current" && new Set(["review", "integrating", "integrated"]).has(worktree.status)) {
+        try {
+          const source = runtime.safeWorkPathSync(resolvedRoot, worktree.workspace_ref, {mustExist:true,type:"directory"});
+          if (gitOutput(source, ["status", "--porcelain"])) errors.push(`${label}: source worktree is dirty`);
+        } catch (error) { errors.push(`${label}: source worktree missing before cleanup: ${error.message}`); }
+      }
+      if (integration?.candidate_sha) {
+        if (gitOutput(resolvedRoot, ["rev-parse", `${integration.candidate_sha}^{tree}`]) !== integration.candidate_tree_sha) errors.push(`${label}: candidate tree differs from recorded tree`);
+        for (const sha of [integration.parent_before_sha, worktree.source_checkpoint]) {
+          if (sha && !gitSucceeds(resolvedRoot, ["merge-base", "--is-ancestor", sha, integration.candidate_sha])) errors.push(`${label}: candidate must contain parent and source checkpoints`);
+        }
+      }
+      const parent = gitOutput(resolvedRoot, ["rev-parse", worktree.parent_branch]);
+      if (worktree.status === "integrating" && worktree.workspace_ref !== "current") {
+        try {
+          const candidate = runtime.safeWorkPathSync(resolvedRoot, integration.candidate_workspace_ref, {mustExist:true,type:"directory"});
+          if (gitOutput(candidate, ["rev-parse", "--path-format=absolute", "--git-common-dir"]) !== gitOutput(resolvedRoot, ["rev-parse", "--path-format=absolute", "--git-common-dir"]) || gitOutput(candidate, ["branch", "--show-current"]) !== integration.candidate_branch || gitOutput(candidate, ["status", "--porcelain"])) errors.push(`${label}: candidate must be a clean worktree of the recorded repository and branch`);
+        } catch (error) { errors.push(`${label}: candidate cannot be inspected: ${error.message}`); }
+      }
+      if (worktree.status === "integrating" && parent !== integration?.parent_before_sha) errors.push(`${label}: parent HEAD drifted; candidate must be marked stale and rebuilt`);
+      if (new Set(["failed", "stale"]).has(integration?.status) && parent === integration.candidate_sha && parent !== integration.parent_before_sha) errors.push(`${label}: failed or stale candidate has already advanced the parent; reconcile before continuing`);
+      if (new Set(["integrated", "removed"]).has(worktree.status)) {
+        if (parent !== integration?.result_sha) errors.push(`${label}: parent branch HEAD must equal recorded result_sha`);
+        if (!gitSucceeds(resolvedRoot, ["merge-base", "--is-ancestor", worktree.source_checkpoint, parent])) errors.push(`${label}: parent must contain source_checkpoint`);
+      }
+    }
     if (new Set(["integrated", "removed"]).has(worktree.status) && gitOutput(resolvedRoot, ["status", "--porcelain"])) {
       errors.push(`${label}: repository is dirty while Ticket is recorded as ${worktree.status}`);
     }
   }
 }
 
-function validateParentImplementation(change, parentStatus, stage, errors, warnings, repoRoot = null) {
+function validateParentImplementation(change, parentStatus, stage, errors, warnings, repoRoot = null, options = {}) {
   const mapPath = join(change, "implementation-map.md");
   const planPath = join(change, "implementation-plan.md");
   if (!isFile(mapPath)) errors.push("parent implementation requires implementation-map.md");
@@ -2868,7 +2650,7 @@ function validateParentImplementation(change, parentStatus, stage, errors, warni
   const map = parseFrontmatter(mapPath);
   const plan = parseFrontmatter(planPath);
   const mapKeys = ["schema_version", "artifact", "change", "status", "revision", "members", "tasks", "dependencies", "serializations"];
-  const planKeys = ["schema_version", "artifact", "change", "status", "source_map_revision", "orchestration", "lead", "implementation_agent_limit", "integration_attempt_limit", "ticket_workspace_policy", "integration_gate", "ready_for_execution"];
+  const planKeys = ["schema_version", "artifact", "change", "status", "source_map_revision", "orchestration", "lead", "concurrent_implementation_limit", "integration_attempt_limit", "ticket_workspace_policy", "integration_gate", "ready_for_execution"];
   for (const [label, meta, expected] of [
     ["implementation-map.md", map.meta, mapKeys],
     ["implementation-plan.md", plan.meta, planKeys],
@@ -2899,7 +2681,7 @@ function validateParentImplementation(change, parentStatus, stage, errors, warni
   if (plan.meta.orchestration !== "lead-directed" || typeof plan.meta.lead !== "string" || !plan.meta.lead.trim()) {
     errors.push("implementation-plan.md: lead-directed orchestration requires a recoverable Lead");
   }
-  for (const key of ["implementation_agent_limit", "integration_attempt_limit"]) {
+  for (const key of ["concurrent_implementation_limit", "integration_attempt_limit"]) {
     if (!Number.isInteger(plan.meta[key]) || plan.meta[key] < 1) {
       errors.push(`implementation-plan.md: ${key} must be a positive integer`);
     }
@@ -2965,7 +2747,8 @@ function validateParentImplementation(change, parentStatus, stage, errors, warni
       errors.push(`implementation-map.md: invalid member change name ${member}`);
       continue;
     }
-    const memberRoot = join(changesRoot, member);
+    let memberRoot;
+    try { memberRoot = runtime.resolveChangeSync(options.context,member,{includeArchived:parentStatus?.location.kind === "archive"}).root; } catch(error) { errors.push(`member change does not exist or has invalid identity: ${member}: ${error.message}`); continue; }
     if (!isDirectory(memberRoot)) {
       errors.push(`implementation-map.md: member change does not exist: ${member}`);
       continue;
@@ -2976,13 +2759,11 @@ function validateParentImplementation(change, parentStatus, stage, errors, warni
 
     const memberErrors = [];
     const memberWarnings = [];
-    const status = validateChangeStatus(join(memberRoot, ".status.json"), member, memberErrors);
+    const status = validateChangeExecution(memberRoot, memberErrors, options.context);
     if (status) {
       memberStatuses.set(member, status);
-      if (status.change_status === "archived") memberErrors.push("archived change cannot be an implementation member");
-      if (status.current_work !== null && status.current_work !== "specdev/implement") {
-        memberErrors.push(`current_work=${status.current_work} conflicts with parent implementation ownership`);
-      }
+      if (parentStatus?.outcome === "completed") validateGitEvidence(options.context.projectRoot,status,memberErrors);
+      if (parentStatus?.location.kind !== "archive" && status.location.kind !== "active") memberErrors.push("archived change cannot be an implementation member");
       for (const worktree of Array.isArray(status.worktrees) ? status.worktrees : []) {
         if (worktree?.status === "active") {
           activeImplementations += 1;
@@ -3092,7 +2873,7 @@ function validateParentImplementation(change, parentStatus, stage, errors, warni
       const uncovered = [...declared].filter((id) => !covered.has(id) && !(childMap && new RegExp(`${escapeRegExp(id)}.*\\bdeferred\\b`, "i").test(childMap.body)));
       if (uncovered.length) memberErrors.push(`Spec acceptance contracts are not covered by Tickets: ${JSON.stringify(uncovered.sort())}`);
     }
-    if (status?.change_status === "completed") {
+    if (status?.outcome === "completed") {
       const unfinished = [...childTickets].filter(([, artifact]) => !new Set(["done", "cancelled"]).has(artifact.meta.status)).map(([id]) => id);
       if (unfinished.length) memberErrors.push(`completed member has unfinished Tickets: ${JSON.stringify(unfinished)}`);
     }
@@ -3207,30 +2988,18 @@ function validateParentImplementation(change, parentStatus, stage, errors, warni
     if (!Array.isArray(otherMap.members)) continue;
     let otherStatus = null;
     try {
-      otherStatus = JSON.parse(readText(join(changesRoot, entry.name, ".status.json"))).change_status;
+      otherStatus = runtime.readChangeFactsSync(options.context, entry.name).outcome;
     } catch {
       // Invalid competing parents still own their members conservatively.
     }
-    if (new Set(["completed", "archived"]).has(otherStatus)) continue;
+    if (new Set(["completed", "cancelled"]).has(otherStatus)) continue;
     const overlap = otherMap.members.map(String).filter((member) => memberSet.has(member));
     if (overlap.length) errors.push(`member changes already belong to unfinished parent implementation ${entry.name}: ${JSON.stringify(overlap)}`);
   }
 
-  const config = findSpecdevConfig(change, repoRoot);
-  const configuredAgents = positiveConfigLimit(config, "max_implementation_agents", 0);
-  const configuredAttempts = positiveConfigLimit(config, "max_integration_attempts", 0);
-  if (!config || config.schema_version !== CONFIG_SCHEMA_VERSION || configuredAgents === 0 || configuredAttempts === 0) {
-    errors.push("implementation-plan.md: SpecDev config v6 with positive execution limits is required");
-  } else {
-    if (plan.meta.implementation_agent_limit > configuredAgents) {
-      errors.push(`implementation-plan.md: implementation_agent_limit ${plan.meta.implementation_agent_limit} exceeds config max_implementation_agents ${configuredAgents}`);
-    }
-    if (plan.meta.integration_attempt_limit > configuredAttempts) {
-      errors.push(`implementation-plan.md: integration_attempt_limit ${plan.meta.integration_attempt_limit} exceeds config max_integration_attempts ${configuredAttempts}`);
-    }
-  }
-  if (activeImplementations > plan.meta.implementation_agent_limit) {
-    errors.push(`parent implementation agent limit exceeded: ${activeImplementations} active for limit ${plan.meta.implementation_agent_limit}`);
+  errors.push(...validateExecutionPolicy(plan, findSpecdevConfig(change, repoRoot, options)).map(error => `implementation-plan.md: ${error}`));
+  if (activeImplementations > plan.meta.concurrent_implementation_limit) {
+    errors.push(`parent implementation agent limit exceeded: ${activeImplementations} active for limit ${plan.meta.concurrent_implementation_limit}`);
   }
   if (plan.meta.ticket_workspace_policy === "current" && activeCurrentWriters > 1) {
     errors.push(`parent current policy permits only one active implementation writer; found ${activeCurrentWriters}`);
@@ -3239,24 +3008,14 @@ function validateParentImplementation(change, parentStatus, stage, errors, warni
     if (count > 1) errors.push(`repository/ref integration must be serialized for ${ref}; found ${count}`);
   }
 
-  if (stage === "goal-plan" && parentStatus && new Set(["active", "blocked"]).has(parentStatus.change_status) && !new Set(["specdev/goal-plan"]).has(parentStatus.current_work)) {
-    errors.push("parent active/blocked status must keep current_work=specdev/goal-plan");
-  }
-  if (parentStatus?.change_status === "completed") {
-    const incomplete = members.filter((member) => memberStatuses.get(member)?.change_status !== "completed");
+  if (parentStatus?.outcome === "completed") {
+    const incomplete = members.filter((member) => memberStatuses.get(member)?.outcome !== "completed");
     if (incomplete.length) errors.push(`parent implementation is completed while members remain incomplete: ${JSON.stringify(incomplete)}`);
     const unfinished = [...ticketByTask].filter(([, value]) => !new Set(["done", "cancelled"]).has(value.artifact.meta.status)).map(([task]) => task);
     if (unfinished.length) errors.push(`completed parent implementation has unfinished composite tasks: ${JSON.stringify(unfinished)}`);
     if (map.meta.status !== "completed" || plan.meta.status !== "completed") {
       errors.push("completed parent requires completed Implementation Map and Implementation Plan");
     }
-    if (
-      parentStatus.current_work !== null ||
-      !Array.isArray(parentStatus.blockers) || parentStatus.blockers.length > 0 ||
-      !Array.isArray(parentStatus.deviations) || parentStatus.deviations.length > 0
-    ) {
-      errors.push("completed parent requires null current_work and no blockers or deviations");
-    }
     const activeMemberWork = [...memberStatuses]
       .flatMap(([member, status]) => (status.worktrees ?? []).map((worktree) => ({ member, worktree })))
       .filter(({ worktree }) => new Set(["planned", "active", "review", "integrating", "blocked"]).has(worktree?.status) || worktree?.integration?.status === "candidate")
@@ -3300,23 +3059,47 @@ function validateParentImplementation(change, parentStatus, stage, errors, warni
   return { map, plan, members, tasks, memberStatuses, ticketByTask };
 }
 
-function validateChange(change, stage = null, repoRoot = null, engineeringKind = null) {
+function validateChange(change, stage = null, repoRoot = null, engineeringKind = null, prototypeId = null, options = {}) {
   const errors = [];
   const warnings = [];
+  const archiveReady = stage === "archive-ready";
+  if (archiveReady) stage = "complete";
   if (!isDirectory(change)) {
     return { errors: [`change directory does not exist: ${change}`], warnings };
   }
 
-  const workspace = resolveWorkspaceContract(repoRoot, change);
+  const workspace = resolveWorkspaceContract(repoRoot, change, options);
   errors.push(...workspace.errors);
+  if (errors.length) return {errors,warnings};
+  options = {...options, context:workspace.context};
+  change = canonicalToolPath(workspace.context, change);
+
+  // Resolve every consumed artifact subtree before individual validators can read it.
+  // Unrelated preserved links are not consumers and remain in the archive manifest.
+  if(stage !== 'archived') try {
+    for(const name of ['README.md','spec.md','goal-plan.md','implementation-map.md','implementation-plan.md','tickets-map.md','DESIGN.md','design-tree.json','source.md','triage.md','publish.md','diagnosis.md','wayfinder-map.md','LOG.md','ticket','evidence','investigation','learning','reviews','prototypes']) {
+      const path=runtime.safeWorkPathSync(change,name);
+      if(isDirectory(path)) for(const child of walk(path)) runtime.safeWorkPathSync(change,toPosix(relative(change,child)));
+    }
+  }catch(error){return {errors:[...errors,error.message],warnings};}
 
   // A partial parent must never fall back to the single-change artifact contract.
   const mapPath = join(change, "tickets-map.md");
   const isParentImplementation = isFile(join(change, "implementation-map.md")) ||
     isFile(join(change, "implementation-plan.md")) ||
     (isFile(mapPath) && parseFrontmatter(mapPath).meta.artifact === "goal-tickets-map");
-  const changeStatus = validateChangeStatus(join(change, ".status.json"), basename(change), errors);
-  if (isParentImplementation) validateParentImplementation(change, changeStatus, stage, errors, warnings, repoRoot);
+  const changeStatus = stage === "archived" ? null : validateChangeExecution(change, errors, workspace.context);
+  if (errors.length) return {errors,warnings};
+  if (stage === "complete" || changeStatus?.outcome === "completed") errors.push(...validateChangeClosure({context:workspace.context,change:basename(change),forArchive:archiveReady}).errors);
+  if (archiveReady && changeStatus?.outcome === "cancelled") return {errors,warnings};
+  if (stage === "archived") {
+    const output=runDesignCheck("--archived", change, errors, workspace.context,options.sealed ? ['--sealed'] : []);
+    let archive;
+    if(output) {try {archive=JSON.parse(output);}catch {errors.push('archived consumer returned no verified receipt result');}}
+    if(archive?.archive_state === 'moved') warnings.push('archive moved and checked, but is not sealed; finish the original A8 receipt');
+    return { errors, warnings, ...(archive ? {archive} : {}) };
+  }
+  if (isParentImplementation) validateParentImplementation(change, changeStatus, stage, errors, warnings, repoRoot, options);
   errors.push(...validateInitiative(change));
   if (isFile(join(change, "source-issue.md"))) {
     errors.push("obsolete source-issue.md is forbidden; use source.md without compatibility fallback");
@@ -3331,7 +3114,7 @@ function validateChange(change, stage = null, repoRoot = null, engineeringKind =
     : null;
   const triagePath = join(change, "triage.md");
   const triage = isFile(triagePath) || sourceRequired
-    ? validateTriage(triagePath, basename(change), errors, changeStatus?.archived === true && stage === null)
+    ? validateTriage(triagePath, basename(change), errors)
     : null;
   const publishPath = join(change, "publish.md");
   const publishRequired = Boolean(
@@ -3345,34 +3128,40 @@ function validateChange(change, stage = null, repoRoot = null, engineeringKind =
     validateDiagnosis(diagnosisPath, basename(change), errors);
   }
   validateReviews(change, stage === "review", errors);
-  validatePrototypes(change, stage === "prototype", errors);
-  validateChangeLearning(change, stage === "learn-change", errors);
+  validatePrototypes(change, stage === "prototype", errors, prototypeId, new Set(["spec", "tickets", "goal-plan", "implement", "review", "complete"]).has(stage), workspace.context);
+  if (new Set(["tickets", "goal-plan", "implement", "review", "complete"]).has(stage)) runDesignCheck("--handoff", change, errors, workspace.context);
+  validateChangeLearning(change, stage === "learn", errors);
   const retro = validateRecords(change, "retrospective", parseFrontmatter);
   const prs = validateRecords(change, "pull-request", parseFrontmatter);
   errors.push(...retro.errors, ...prs.errors);
   if (stage === "retro" && !retro.records.some(r => r.meta.status === "completed")) errors.push("retro stage requires a completed retrospective");
   if (stage === "pr-delivery" && !prs.records.length) errors.push("pr-delivery stage requires a PR record");
-  if (stage === "complete" && prs.records.some(r => r.meta.requested === true && (["planned", "failed"].includes(r.meta.status) || (r.meta.delivery_target === "ready" && r.meta.status === "draft")))) errors.push("complete stage cannot archive pending PR delivery");
+  if (archiveReady && prs.records.some(r => r.meta.requested === true && (["planned", "failed"].includes(r.meta.status) || (r.meta.delivery_target === "ready" && r.meta.status === "draft")))) errors.push("complete stage cannot archive pending PR delivery");
   const retroOnly = retro.records.length > 0 && retro.errors.length === 0 && retro.records.every(r => r.meta.status === "completed") &&
-    changeStatus?.works_run?.includes("specdev/retro") && changeStatus.works_run.every(w => ["specdev/retro", "specdev/triage"].includes(w)) &&
     !["spec.md", "ticket", "tickets-map.md", "goal-plan.md", "implementation-map.md", "implementation-plan.md", "evidence"].some(p => existsSync(join(change,p))) && !changeStatus.worktrees?.length;
 
+  let simpleGoal = null;
+  try { simpleGoal = readLightweightGoal(change); } catch (error) { errors.push(error.message); }
   const specRequired = new Set(["spec", "tickets", "goal-plan", "implement", "complete"]).has(stage) && !isParentImplementation && !retroOnly;
   const specPath = join(change, "spec.md");
-  const spec = isFile(specPath) || specRequired
-    ? validateSpec(specPath, errors, warnings)
-    : null;
+  let specification = null;
+  if (!isParentImplementation && !retroOnly && (isFile(specPath) || specRequired)) {
+    try { specification = readSpecification(change, {allowLightweight: stage !== "tickets" && (stage !== "goal-plan" || Boolean(simpleGoal)), requiredArtifact:options.requiredArtifact, depth:options.depth}); }
+    catch(error) { errors.push(error.message); }
+  }
+  const lightweight = specification?.lightweight === true;
+  const spec = isFile(specPath) ? validateSpec(specPath, errors, warnings) : null;
   const ticketMode = isDirectory(join(change, "ticket"));
-  const mapRequired = !isParentImplementation && (new Set(["tickets", "goal-plan"]).has(stage) || (stage === "implement" && ticketMode));
+  const mapRequired = !simpleGoal && !isParentImplementation && (new Set(["tickets", "goal-plan"]).has(stage) || (stage === "implement" && ticketMode));
   const ticketsMap = isFile(mapPath) || mapRequired ? validateMap(mapPath, errors, repoRoot) : null;
   const goalPlanPath = join(change, "goal-plan.md");
-  const goalPlan = isFile(goalPlanPath) || (stage === "goal-plan" && !isParentImplementation)
+  const goalPlan = !simpleGoal && (isFile(goalPlanPath) || (stage === "goal-plan" && !isParentImplementation))
     ? validateGoalPlan(goalPlanPath, errors)
     : null;
   validateDesignTree(join(change, "design-tree.json"), change, errors);
   validateWayfinder(change, errors);
   if (stage === "grill") {
-    for (const name of ["design-tree.json", "LOG.md", "CONTEXT.md", "ADR.md"]) {
+    for (const name of ["design-tree.json"]) {
       if (!isFile(join(change, name))) errors.push(`grill stage requires ${name}`);
     }
   }
@@ -3386,7 +3175,7 @@ function validateChange(change, stage = null, repoRoot = null, engineeringKind =
   }
 
   const ticketDir = join(change, "ticket");
-  const ticketsRequired = !isParentImplementation && (new Set(["tickets", "goal-plan"]).has(stage) || (stage === "implement" && ticketMode));
+  const ticketsRequired = !simpleGoal && !isParentImplementation && (new Set(["tickets", "goal-plan"]).has(stage) || (stage === "implement" && ticketMode));
   const ticketFiles = isDirectory(ticketDir)
     ? readdirSync(ticketDir)
         .filter((name) => name.endsWith(".md"))
@@ -3395,7 +3184,7 @@ function validateChange(change, stage = null, repoRoot = null, engineeringKind =
     : [];
   if (ticketsRequired && !isDirectory(ticketDir)) errors.push("missing Ticket directory");
   if (ticketsRequired && !ticketFiles.length) errors.push("Ticket directory contains no Markdown tickets");
-  if (stage === "implement" && !ticketMode && !isFile(join(change, "evidence", "direct-spec.md"))) {
+  if (stage === "implement" && !ticketMode && !lightweight && !isFile(join(change, "evidence", "direct-spec.md"))) {
     errors.push("Direct Spec implement stage requires evidence/direct-spec.md");
   }
 
@@ -3455,7 +3244,7 @@ function validateChange(change, stage = null, repoRoot = null, engineeringKind =
     }
   }
   if (changeStatus && goalPlan) {
-    validateGoalPlanRuntimeLimits(goalPlan.path, change, goalPlan, errors, repoRoot);
+    validateGoalPlanRuntimeLimits(goalPlan.path, change, goalPlan, errors, repoRoot, options);
     const attemptLimit = Number.isInteger(goalPlan.meta.integration_attempt_limit) ? goalPlan.meta.integration_attempt_limit : null;
     if (attemptLimit !== null) {
       for (const worktree of changeStatus.worktrees ?? []) {
@@ -3464,11 +3253,20 @@ function validateChange(change, stage = null, repoRoot = null, engineeringKind =
         }
       }
     }
-    validateCurrentWorkspaceExecution(changeStatus, goalPlan, errors);
   }
-  validateGitEvidence(repoRoot, changeStatus, errors);
+  validateCurrentWorkspaceExecution(changeStatus, goalPlan, errors);
+  const directExecution = changeStatus?.worktrees?.find(entry => entry.purpose === "direct-spec");
+  if (directExecution && workspace.config) errors.push(...validateExecutionPolicy({meta:{concurrent_implementation_limit:1,integration_attempt_limit:directExecution.integration_attempt_limit}},workspace.config).map(error => `Direct Spec: ${error}`));
+  if (directExecution && (ticketMode || isParentImplementation)) errors.push("Direct Spec execution cannot coexist with Ticket or parent implementation artifacts");
+  if (directExecution && (stage === "complete" || changeStatus.outcome === "completed") && !new Set(["integrated", "removed"]).has(directExecution.status)) errors.push("Direct Spec completion requires integrated or removed execution; active or failed candidates cannot complete");
+  validateGitEvidence(stage === "complete" ? workspace.context.projectRoot : repoRoot, changeStatus, errors);
 
-  if (spec) {
+  if (stage === "implement" && spec && !ticketMode && (spec.meta.ready_for_tickets !== true || spec.meta.status !== "ready")) errors.push("Direct Spec implementation requires a ready Spec with ready_for_tickets=true");
+  if (spec?.meta.ready_for_tickets === true && !/\bAC-\d+\b/.test(spec.body)) errors.push("ready Spec must define at least one AC-### acceptance contract");
+
+  if (stage === "complete" && spec && !ticketMode && !isParentImplementation && !retroOnly) errors.push(...validateAcceptanceEvidence(change,"evidence/direct-spec.md",[...new Set(spec.body.match(/\bAC-\d+\b/g) ?? [])]));
+
+  if (spec && ticketMode) {
     const declaredContracts = new Set(spec.body.match(/\bAC-\d+\b/g) ?? []);
     const coveredContracts = new Set(
       [...tickets.values()].flatMap((artifact) =>
@@ -3553,7 +3351,7 @@ function validateChange(change, stage = null, repoRoot = null, engineeringKind =
       continue;
     }
     const text = readText(evidence);
-    const currentWorkspace = goalPlan?.meta.ticket_workspace_policy === "current";
+    const currentWorkspace = changeStatus?.worktrees?.find(entry => entry.ticket_id === ticketId)?.workspace_ref === "current";
     const requiredHeadings = [
       "## 2. Lead Dispatch And Candidate Return",
       "## 3. 修改范围与路径所有权",
@@ -3598,44 +3396,44 @@ function validateChange(change, stage = null, repoRoot = null, engineeringKind =
 
   if (changeStatus) {
     if (
-      changeStatus.change_status === "completed" &&
+      changeStatus.outcome === "completed" &&
       [...tickets.values()].some(
         (artifact) => !new Set(["done", "cancelled"]).has(artifact.meta.status),
       )
     ) {
-      errors.push("change_status is completed while planned Tickets remain unfinished");
+      errors.push("Outcome is completed while planned Tickets remain unfinished");
     }
-    if (changeStatus.change_status === "archived") {
+    if (changeStatus.location.kind === "archive") {
       warnings.push("validating an archived change in place; normally it lives under the archive root");
     }
-    if (stage === "complete" && changeStatus.change_status !== "completed") {
-      errors.push("complete stage requires change_status=completed");
+    if (stage === "complete" && changeStatus.outcome !== "completed") {
+      errors.push("complete stage requires Outcome: completed");
     }
   }
   if (
     stage === "complete" &&
-    !ticketFiles.length && !retroOnly &&
+    !ticketFiles.length && !retroOnly && !lightweight &&
     !isFile(join(change, "implementation-map.md")) &&
     !isFile(join(change, "evidence", "direct-spec.md"))
   ) {
     errors.push("complete stage without Tickets requires evidence/direct-spec.md");
   }
   if (
-    stage === "complete" &&
+    archiveReady &&
     triage &&
     new Set(["pending-close", "close-failed"]).has(triage.meta.external_action)
   ) {
     errors.push(`complete stage cannot archive external_action=${triage.meta.external_action}`);
   }
   if (
-    stage === "complete" &&
+    archiveReady &&
     triage &&
     new Set(["pending", "publish-failed"]).has(triage.meta.publish_action)
   ) {
     errors.push(`complete stage cannot archive publish_action=${triage.meta.publish_action}`);
   }
 
-  for (const path of walk(change).filter((item) => isFile(item) && extname(item) === ".md")) {
+  for (const path of walk(change).filter((item) => lstatSync(item).isFile() && extname(item) === ".md")) {
     const text = readText(path);
     if ((text.match(/<Path>/g) ?? []).length !== (text.match(/<\/Path>/g) ?? []).length) {
       errors.push(`${toPosix(relative(change, path))}: unbalanced <Path> tags`);
@@ -3651,7 +3449,18 @@ function validateChange(change, stage = null, repoRoot = null, engineeringKind =
   }
 
   errors.push(...validateEngineeringArtifacts(change, engineeringKind));
-  return { errors, warnings };
+  if (simpleGoal && changeStatus?.outcome === "completed" && /^[-*] \[ \]/m.test(simpleGoal.body)) errors.push("completed Goal still has unfinished tasks");
+  return { errors, warnings, ...(options.readOnlySnapshot ? {snapshot:true,preflight:true} : {}) };
+}
+
+function contextArguments(context) {
+  if (!context) return [];
+  const source = context.readOnlySnapshot?.sourceContext ?? context;
+  return ['--repo',source.projectRoot,'--method-root',source.methodRoot,'--state-root',source.specdevRoot,...(context.readOnlySnapshot ? ['--snapshot-specdev',context.specdevRoot] : [])];
+}
+function runDesignCheck(operation, path, errors, context = null, flags = []) {
+  try { return execFileSync(process.execPath, [fileURLToPath(new URL("./design-artifacts.mjs", import.meta.url)), operation, path, ...contextArguments(context),...flags], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }); }
+  catch (error) { errors.push(String(error.stderr || error.stdout || error.message).trim()); }
 }
 
 function printResults(errors, warnings) {
@@ -3662,22 +3471,30 @@ function printResults(errors, warnings) {
 }
 
 function usage() {
-  console.error("Usage: node validate-specdev.mjs [--stage <stage>] [--repo <project-root>] [--engineering <performance|documentation|incident>] <change-directory> | --review-scope --repo <project-root> --mode <baseline|range|commit|pr> [comparison options] | --self-check | --capture <capture.md> | --triage-run <TRI-NNN.md>");
+  console.error("Usage: node validate-specdev.mjs [--stage <stage>] [--sealed (archived only)] [--prototype-id UI-NNN|LOGIC-NNN] [--repo <project-root>] [--engineering <performance|documentation|incident>] <change-directory> | --review-scope --repo <project-root> --mode <baseline|range|commit|pr|source-files> [comparison options or repeated --file <relative-path>] | --self-check | --capture <capture.md> | --triage-run <TRI-NNN.md>");
   return 2;
 }
 
 function main(argv) {
   if (argv[0] === "--review-scope") return reviewScopeCLI(argv.slice(1));
   let engineeringKind = null;
+  let prototypeId = null;
   let selfCheckRequested = false;
   let stage = null;
   let repoRoot = null;
+  const contextOptions = {};
   let capturePath = null;
   let triageRunPath = null;
   const positional = [];
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
-    if (arg === "--engineering") {
+    if (arg === "--prototype-id") {
+      if (prototypeId !== null || !/^(?:UI|LOGIC)-\d{3,}$/.test(argv[index + 1] ?? "")) return usage();
+      prototypeId = argv[++index];
+    } else if (arg === "--sealed") {
+      if(contextOptions.sealed) return usage();
+      contextOptions.sealed=true;
+    } else if (arg === "--engineering") {
       if (engineeringKind !== null || !ENGINEERING_KINDS.has(argv[index + 1])) return usage();
       engineeringKind = argv[++index];
     } else if (arg === "--self-check") {
@@ -3687,6 +3504,8 @@ function main(argv) {
       index += 1;
     } else if (arg.startsWith("--stage=")) {
       stage = arg.slice("--stage=".length);
+    } else if (arg === "--method-root" || arg === "--state-root") {
+      contextOptions[arg === "--method-root" ? "methodRoot" : "stateRoot"] = argv[++index];
     } else if (arg === "--repo") {
       repoRoot = argv[index + 1] ?? null;
       index += 1;
@@ -3706,6 +3525,8 @@ function main(argv) {
     }
   }
   if (stage !== null && !VALID_STAGES.has(stage)) return usage();
+  if(contextOptions.sealed && stage !== 'archived') return usage();
+  if (prototypeId && stage !== "prototype") return usage();
   if (engineeringKind !== null && (selfCheckRequested || capturePath || triageRunPath || positional.length !== 1)) return usage();
   if (triageRunPath) {
     if (selfCheckRequested || positional.length || stage !== null || capturePath || repoRoot) return usage();
@@ -3725,7 +3546,7 @@ function main(argv) {
     return printResults(errors, []);
   }
   if (positional.length === 1) {
-    const result = validateChange(resolve(positional[0]), stage, repoRoot, engineeringKind);
+    const result = validateChange(resolve(positional[0]), stage, repoRoot, engineeringKind, prototypeId, contextOptions);
     return printResults(result.errors, result.warnings);
   }
   return usage();