project-tiny-context-harness 0.2.78 → 0.2.80

package/dist/commands/composite-long-task.d.ts

@@ -0,0 +1,6 @@
+export declare function compositeLongTask(args: string[]): Promise<void>;
+export declare function runCompositeLongTaskCommand(args: string[], options: {
+    commandName: string;
+    label: string;
+    showHelp: boolean;
+}): Promise<void>;

package/dist/commands/composite-long-task.js

@@ -0,0 +1,103 @@
+import path from "node:path";
+import { applySliceDelta, initializeSuperpowersTask } from "../lib/superpowers-task-state.js";
+import { compileSuperpowersTask } from "../lib/superpowers-task-compile.js";
+import { deriveSuperpowersArtifacts } from "../lib/superpowers-task-derive.js";
+import { runEpochGate, runFinalGate, runSliceGate } from "../lib/superpowers-task-gates.js";
+import { nextSuperpowersSlices } from "../lib/superpowers-task-next-slices.js";
+import { renderCompositeLongTaskGoal } from "../lib/composite-long-task-renderer.js";
+export async function compositeLongTask(args) {
+    await runCompositeLongTaskCommand(args, {
+        commandName: "ty-context composite-long-task",
+        label: "composite long-task",
+        showHelp: true
+    });
+}
+export async function runCompositeLongTaskCommand(args, options) {
+    const subcommand = args[0] ?? "help";
+    const workdirArg = args[1];
+    if (!workdirArg || subcommand === "help") {
+        help(options.commandName, options.showHelp);
+        return;
+    }
+    const workdir = path.resolve(process.cwd(), workdirArg);
+    if (subcommand === "init") {
+        await initializeSuperpowersTask(workdir, { planSlug: path.basename(workdir) });
+        console.log(`initialized ${options.label} state at ${workdirArg}/task-state.json`);
+        return;
+    }
+    if (subcommand === "compile") {
+        const state = await compileSuperpowersTask(workdir);
+        console.log(`compiled ${options.label} graph plan_items=${Object.keys(state.graph.plan_items).length} acs=${Object.keys(state.graph.acceptance_criteria).length}`);
+        return;
+    }
+    if (subcommand === "apply-slice-delta") {
+        const delta = args[2];
+        if (!delta) {
+            throw new Error("apply-slice-delta requires <slice-delta.json>");
+        }
+        await applySliceDelta(workdir, path.resolve(process.cwd(), delta));
+        const result = await deriveSuperpowersArtifacts(workdir);
+        console.log(`applied ${options.label} slice delta and derived files=${result.files.length}`);
+        return;
+    }
+    if (subcommand === "derive") {
+        const result = await deriveSuperpowersArtifacts(workdir);
+        console.log(`derived ${options.label} artifacts files=${result.files.length}`);
+        return;
+    }
+    if (subcommand === "slice-gate") {
+        const sliceId = optionValue(args, "--slice") ?? "";
+        const result = await runSliceGate(workdir, sliceId);
+        console.log(result.passed ? `slice gate passed ${sliceId}` : `slice gate blocked ${result.messages.join("; ")}`);
+        if (!result.passed) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (subcommand === "epoch-gate") {
+        const epochId = optionValue(args, "--epoch") ?? "";
+        const result = await runEpochGate(workdir, epochId);
+        console.log(result.passed ? `epoch gate passed ${epochId}` : `epoch gate blocked ${result.messages.join("; ")}`);
+        return;
+    }
+    if (subcommand === "final-gate") {
+        const result = await runFinalGate(workdir);
+        console.log(`final gate product_goal_complete=${result.product_goal_complete}`);
+        if (!result.product_goal_complete) {
+            process.exitCode = 1;
+            for (const error of result.errors) {
+                console.error(`error: ${error}`);
+            }
+        }
+        return;
+    }
+    if (subcommand === "next-slices") {
+        const limit = Number.parseInt(optionValue(args, "--limit") ?? "5", 10);
+        const slices = await nextSuperpowersSlices(workdir, Number.isFinite(limit) ? limit : 5);
+        console.log(`Next ${Math.min(Number.isFinite(limit) ? limit : 5, 5)} high-value clusters:`);
+        console.log(slices.join("\n"));
+        return;
+    }
+    if (subcommand === "render-goal") {
+        const result = await renderCompositeLongTaskGoal(workdir);
+        console.log(`rendered ${options.label} goal artifacts: ${path.basename(result.goalObjectivePath)} ${path.basename(result.protocolPath)} ${path.basename(result.executionBindingPath)} length=${result.goalObjectiveLength}`);
+        return;
+    }
+    help(options.commandName, options.showHelp);
+}
+function help(commandName, showRenderGoal) {
+    const renderGoal = showRenderGoal ? "\n  render-goal <workdir>                  Render workflow-protocol.md, execution-binding.md and goal-objective.txt" : "";
+    console.log(`${commandName} commands:
+  init <workdir>                         Initialize task-state.json and events.ndjson
+  compile <workdir>                      Compile sources into task graph
+  apply-slice-delta <workdir> <delta>    Apply structured slice delta, evidence and derived views
+  derive <workdir>                       Generate derived/** views
+  slice-gate <workdir> --slice <id>      Validate one slice has real progress
+  epoch-gate <workdir> --epoch <id>      Refresh shared epoch evidence views
+  final-gate <workdir>                   Compute product_goal_complete
+  next-slices <workdir> --limit 5        Recommend next proof clusters${renderGoal}`);
+}
+function optionValue(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}

package/dist/commands/index.js

@@ -1,4 +1,5 @@
 import { checkModularity } from "./check-modularity.js";
+import { compositeLongTask } from "./composite-long-task.js";
 import { doctor } from "./doctor.js";
 import { exportContext } from "./export-context.js";
 import { init } from "./init.js";
@@ -22,6 +23,7 @@ export const commands = {
     "validate-plan-contract": (args) => validate(["validate-plan-contract", ...args]),
     "validate-plan-acceptance": (args) => validate(["validate-plan-acceptance", ...args]),
     "validate-superpowers-state": (args) => validate(["validate-superpowers-state", ...args]),
+    "composite-long-task": compositeLongTask,
     superpowers,
     package: packageSource
 };
@@ -47,8 +49,8 @@ export function help() {
   validate-plan-acceptance <dir>
                        Validate plan-conformance matrix and final verdict consistency
   validate-superpowers-state <dir>
-                       Validate canonical Superpowers task-state.json
-  superpowers <subcommand>
-                       Manage explicit Superpowers long-task state workdirs
+                       Validate canonical Superpowers-backed task-state.json
+  composite-long-task <subcommand>
+                       Manage explicit composite long-task workflow workdirs
   package <subcommand> Maintain package canonical source`);
 }

package/dist/commands/superpowers.js

@@ -1,89 +1,8 @@
-import path from "node:path";
-import { applySliceDelta, initializeSuperpowersTask } from "../lib/superpowers-task-state.js";
-import { compileSuperpowersTask } from "../lib/superpowers-task-compile.js";
-import { deriveSuperpowersArtifacts } from "../lib/superpowers-task-derive.js";
-import { runEpochGate, runFinalGate, runSliceGate } from "../lib/superpowers-task-gates.js";
-import { nextSuperpowersSlices } from "../lib/superpowers-task-next-slices.js";
+import { runCompositeLongTaskCommand } from "./composite-long-task.js";
 export async function superpowers(args) {
-    const subcommand = args[0] ?? "help";
-    const workdirArg = args[1];
-    if (!workdirArg || subcommand === "help") {
-        help();
-        return;
-    }
-    const workdir = path.resolve(process.cwd(), workdirArg);
-    if (subcommand === "init") {
-        await initializeSuperpowersTask(workdir, { planSlug: path.basename(workdir) });
-        console.log(`initialized superpowers task state at ${workdirArg}/task-state.json`);
-        return;
-    }
-    if (subcommand === "compile") {
-        const state = await compileSuperpowersTask(workdir);
-        console.log(`compiled superpowers task graph plan_items=${Object.keys(state.graph.plan_items).length} acs=${Object.keys(state.graph.acceptance_criteria).length}`);
-        return;
-    }
-    if (subcommand === "apply-slice-delta") {
-        const delta = args[2];
-        if (!delta) {
-            throw new Error("apply-slice-delta requires <slice-delta.json>");
-        }
-        await applySliceDelta(workdir, path.resolve(process.cwd(), delta));
-        const result = await deriveSuperpowersArtifacts(workdir);
-        console.log(`applied superpowers slice delta and derived files=${result.files.length}`);
-        return;
-    }
-    if (subcommand === "derive") {
-        const result = await deriveSuperpowersArtifacts(workdir);
-        console.log(`derived superpowers artifacts files=${result.files.length}`);
-        return;
-    }
-    if (subcommand === "slice-gate") {
-        const sliceId = optionValue(args, "--slice") ?? "";
-        const result = await runSliceGate(workdir, sliceId);
-        console.log(result.passed ? `slice gate passed ${sliceId}` : `slice gate blocked ${result.messages.join("; ")}`);
-        if (!result.passed) {
-            process.exitCode = 1;
-        }
-        return;
-    }
-    if (subcommand === "epoch-gate") {
-        const epochId = optionValue(args, "--epoch") ?? "";
-        const result = await runEpochGate(workdir, epochId);
-        console.log(result.passed ? `epoch gate passed ${epochId}` : `epoch gate blocked ${result.messages.join("; ")}`);
-        return;
-    }
-    if (subcommand === "final-gate") {
-        const result = await runFinalGate(workdir);
-        console.log(`final gate product_goal_complete=${result.product_goal_complete}`);
-        if (!result.product_goal_complete) {
-            process.exitCode = 1;
-            for (const error of result.errors) {
-                console.error(`error: ${error}`);
-            }
-        }
-        return;
-    }
-    if (subcommand === "next-slices") {
-        const limit = Number.parseInt(optionValue(args, "--limit") ?? "5", 10);
-        const slices = await nextSuperpowersSlices(workdir, Number.isFinite(limit) ? limit : 5);
-        console.log(`Next ${Math.min(Number.isFinite(limit) ? limit : 5, 5)} high-value clusters:`);
-        console.log(slices.join("\n"));
-        return;
-    }
-    help();
-}
-function help() {
-    console.log(`ty-context superpowers commands:
-  init <workdir>                         Initialize task-state.json and events.ndjson
-  compile <workdir>                      Compile sources into task graph
-  apply-slice-delta <workdir> <delta>    Apply structured slice delta, evidence and derived views
-  derive <workdir>                       Generate derived/** views
-  slice-gate <workdir> --slice <id>      Validate one slice has real progress
-  epoch-gate <workdir> --epoch <id>      Refresh shared epoch evidence views
-  final-gate <workdir>                   Compute product_goal_complete
-  next-slices <workdir> --limit 5        Recommend next proof clusters`);
-}
-function optionValue(args, name) {
-    const index = args.indexOf(name);
-    return index >= 0 ? args[index + 1] : undefined;
+    await runCompositeLongTaskCommand(args, {
+        commandName: "ty-context superpowers",
+        label: "superpowers task",
+        showHelp: false
+    });
 }

package/dist/lib/composite-long-task-renderer.d.ts

@@ -0,0 +1,12 @@
+export interface CompositeLongTaskGoalRenderResult {
+    workdir: string;
+    protocolPath: string;
+    protocolSha256: string;
+    executionBindingPath: string;
+    goalObjectivePath: string;
+    goalObjectiveLength: number;
+}
+export declare function renderCompositeLongTaskGoal(workdir: string): Promise<CompositeLongTaskGoalRenderResult>;
+export declare const COMPOSITE_LONG_TASK_WORKFLOW_SKILL_NAME = "composite-long-task-workflow";
+export declare const COMPOSITE_LONG_TASK_PUBLIC_COMMAND = "composite-long-task";
+export declare const COMPOSITE_LONG_TASK_PACKAGE = "project-tiny-context-harness";

package/dist/lib/composite-long-task-renderer.js

@@ -0,0 +1,153 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { CANONICAL_CORE_PACKAGE } from "./constants.js";
+import { pathExists, readText, writeTextIfChanged } from "./fs.js";
+import { packageAssetPath, packageRoot } from "./paths.js";
+const SOURCE_ASSET = "packages/ty-context/assets/skills/composite-long-task-workflow/references/composite-long-task-workflow-protocol.md";
+const REQUIRED_SOURCE_FILES = [
+    "product-architecture-source.md",
+    "technical-realization-plan.md",
+    "acceptance-checklist.md"
+];
+export async function renderCompositeLongTaskGoal(workdir) {
+    const resolvedWorkdir = path.resolve(workdir);
+    await assertReadyWorkdir(resolvedWorkdir);
+    const protocolBody = ensureTrailingNewline(normalizeNewlines(await readText(packageAssetPath("skills", "composite-long-task-workflow", "references", "composite-long-task-workflow-protocol.md"))));
+    const protocolSha256 = sha256(protocolBody);
+    const protocolVersion = await packageVersion();
+    const protocolSnapshot = [
+        "protocol_name: composite-long-task-workflow",
+        `protocol_version: ${protocolVersion}`,
+        `protocol_sha256: ${protocolSha256}`,
+        `generated_at: ${new Date().toISOString()}`,
+        `source_asset: ${SOURCE_ASSET}`,
+        "---",
+        protocolBody.trimEnd()
+    ].join("\n") + "\n";
+    const protocolPath = path.join(resolvedWorkdir, "workflow-protocol.md");
+    await writeTextIfChanged(protocolPath, protocolSnapshot);
+    const executionBinding = renderExecutionBinding(resolvedWorkdir, protocolSha256);
+    const executionBindingPath = path.join(resolvedWorkdir, "execution-binding.md");
+    await writeTextIfChanged(executionBindingPath, executionBinding);
+    const goalObjective = renderGoalObjective(workdirForPrompt(resolvedWorkdir));
+    if (goalObjective.length > 3850) {
+        throw new Error(`goal-objective.txt exceeds 3850 characters (${goalObjective.length})`);
+    }
+    if (/^\/goal\s+read\s+\S+\s*\.?$/i.test(goalObjective.trim())) {
+        throw new Error("goal-objective.txt must not be a single read-file pointer");
+    }
+    const goalObjectivePath = path.join(resolvedWorkdir, "goal-objective.txt");
+    await writeTextIfChanged(goalObjectivePath, goalObjective);
+    return {
+        workdir: resolvedWorkdir,
+        protocolPath,
+        protocolSha256,
+        executionBindingPath,
+        goalObjectivePath,
+        goalObjectiveLength: goalObjective.length
+    };
+}
+async function assertReadyWorkdir(workdir) {
+    for (const sourceFile of REQUIRED_SOURCE_FILES) {
+        const sourcePath = path.join(workdir, sourceFile);
+        if (!(await pathExists(sourcePath))) {
+            throw new Error(`render-goal requires ${sourceFile}; provide the three input files first`);
+        }
+    }
+    const statePath = path.join(workdir, "task-state.json");
+    if (!(await pathExists(statePath))) {
+        throw new Error("render-goal requires task-state.json; run ty-context composite-long-task init/compile before render-goal");
+    }
+    const state = JSON.parse(await readText(statePath));
+    const planItemCount = Object.keys(state.graph?.plan_items ?? {}).length;
+    const acceptanceCriteriaCount = Object.keys(state.graph?.acceptance_criteria ?? {}).length;
+    if (planItemCount === 0 || acceptanceCriteriaCount === 0) {
+        throw new Error("render-goal requires compiled task-state.json; run ty-context composite-long-task compile before render-goal");
+    }
+}
+function renderExecutionBinding(workdir, protocolSha256) {
+    return `# Composite Long-Task Execution Binding
+
+workdir: ${path.normalize(workdir)}
+protocol: workflow-protocol.md
+protocol_sha256: ${protocolSha256}
+goal_objective: goal-objective.txt
+
+authorities:
+  product_architecture_source: product-architecture-source.md
+  technical_realization_plan: technical-realization-plan.md
+  acceptance_checklist: acceptance-checklist.md
+
+canonical_state:
+  task_state: task-state.json
+  events: events.ndjson
+  derived_dir: derived/
+
+required_commands:
+  init: ty-context composite-long-task init <workdir>
+  compile: ty-context composite-long-task compile <workdir>
+  derive: ty-context composite-long-task derive <workdir>
+  apply_slice_delta: ty-context composite-long-task apply-slice-delta <workdir> <slice-delta.json>
+  slice_gate: ty-context composite-long-task slice-gate <workdir> --slice <id>
+  epoch_gate: ty-context composite-long-task epoch-gate <workdir> --epoch <id>
+  state_validator: ty-context validate-superpowers-state <workdir>
+  acceptance_validator: ty-context validate-plan-acceptance <workdir>
+  final_gate: ty-context composite-long-task final-gate <workdir>
+
+completion_gate:
+  product_goal_complete_source: final_gate
+  cannot_hand_set_product_goal_complete: true
+`;
+}
+function renderGoalObjective(workdir) {
+    return `/goal Execute the composite long-task workflow in ${workdir}.
+
+First read and obey:
+- workflow-protocol.md
+- execution-binding.md
+- product-architecture-source.md
+- technical-realization-plan.md
+- acceptance-checklist.md
+- task-state.json and generated derived/** views
+
+Persistent contract:
+Product / Architecture Source owns intent, scope and boundaries. Technical Realization Plan owns PI implementation and plan conformance. Acceptance Checklist owns AC completion semantics and proof layers. task-state.json is the only execution state source; events.ndjson is append-only; derived/** is generated and must not be hand-edited as authority.
+
+Use workflow-protocol.md to combine Tiny Context gates with official Superpowers execution. It is not business Context and must not be registered in project_context/context.toml. Do not redefine, duplicate or fork Superpowers mechanics. Prefer superpowers:subagent-driven-development when subagents are available, otherwise use superpowers:executing-plans. Use TDD for behavior gaps and superpowers:verification-before-completion before completion claims.
+
+Work in slices. Each slice must update state through slice-delta.json, canonical evidence records, derive, and slice-gate. Run epoch-gate for shared provider/browser/runtime/security proof environments. Preserve Context Delta, plan conformance, acceptance proof layers, redaction, reviewability and sample/full-population boundaries.
+
+Forbidden shortcuts:
+Tests alone do not prove plan conformance. Superpowers review does not override Tiny Context gates. Sample evidence does not prove full population unless AC allows. Manual edits under derived/** are not authority. Local audit cannot mark final completion. Do not claim full implementation while Context Delta is required but Context is not updated, or while Source-to-Context Coverage / Context-to-Implementation Binding has unresolved required gaps.
+
+Completion:
+Do not hand-set product_goal_complete. Only complete after derive, verification-before-completion, validate-superpowers-state, validate-plan-acceptance, auditor/stale-overclaim checks when applicable, and final-gate compute product_goal_complete=true. If audit_task_complete is true but acceptance_target_status is not complete, report "Audit workflow completed; acceptance target not complete." and continue or stop with blockers; do not say Goal achieved.
+
+Blocked:
+Maximize safe autonomous progress using repo tools, local app/browser sessions, CLI auth and authorized elevation. Stop only for locally unsatisfiable blockers such as MFA, missing permission, external approval or unavailable credentials, and return the minimal user action list plus next agent step.
+`;
+}
+async function packageVersion() {
+    const packageJson = JSON.parse(await readText(path.join(packageRoot(), "package.json")));
+    return packageJson.version ?? "unknown";
+}
+function workdirForPrompt(workdir) {
+    const cwd = process.cwd();
+    const relative = path.relative(cwd, workdir);
+    if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+        return relative.replace(/\\/g, "/");
+    }
+    return workdir.replace(/\\/g, "/");
+}
+function normalizeNewlines(value) {
+    return value.replace(/\r\n/g, "\n");
+}
+function ensureTrailingNewline(value) {
+    return `${value.trimEnd()}\n`;
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export const COMPOSITE_LONG_TASK_WORKFLOW_SKILL_NAME = "composite-long-task-workflow";
+export const COMPOSITE_LONG_TASK_PUBLIC_COMMAND = "composite-long-task";
+export const COMPOSITE_LONG_TASK_PACKAGE = CANONICAL_CORE_PACKAGE;

package/dist/lib/superpowers-task-compile.js

@@ -2,8 +2,7 @@ import path from "node:path";
 import { readText } from "./fs.js";
 import { appendSuperpowersEvent } from "./superpowers-task-events.js";
 import { loadSuperpowersState, recomputeStatuses, saveSuperpowersState, refreshSourceHashes } from "./superpowers-task-state.js";
-import { asStringArray } from "./superpowers-task-state-schema.js";
-const DEFAULT_LAYERS = ["code", "test"];
+import { DEFAULT_LAYERS, parseAcceptanceCriteria, parsePlanItems, parseProductArchitectureScope } from "./superpowers-task-source-compile.js";
 export async function compileSuperpowersTask(workdir) {
     const state = await loadSuperpowersState(workdir);
     await refreshSourceHashes(workdir, state);
@@ -11,11 +10,11 @@ export async function compileSuperpowersTask(workdir) {
     const technicalPlan = await readText(path.join(workdir, state.sources.technical_realization_plan.path));
     const checklist = await readText(path.join(workdir, state.sources.acceptance_checklist.path));
     state.delivery = {
-        product_architecture_scope: parseProductArchitectureScope(productSource),
+        product_architecture_scope: parseProductArchitectureScope(productSource, state.sources.product_architecture_source.path),
         scope_conflicts: []
     };
-    const planItems = parsePlanItems(technicalPlan);
-    const acceptanceCriteria = parseAcceptanceCriteria(checklist);
+    const planItems = parsePlanItems(technicalPlan, state.sources.technical_realization_plan.path);
+    const acceptanceCriteria = parseAcceptanceCriteria(checklist, state.sources.acceptance_checklist.path);
     const acIds = Object.keys(acceptanceCriteria);
     for (const [planId, item] of Object.entries(planItems)) {
         if (item.related_acs.length === 0) {
@@ -47,95 +46,11 @@ export async function compileSuperpowersTask(workdir) {
     });
     return state;
 }
-function parseProductArchitectureScope(content) {
-    return {
-        delivery_scope: fieldText(content, "delivery_scope"),
-        full_population_required: fieldBoolean(content, "full_population_required"),
-        representative_samples_validate: field(content, "representative_samples_validate"),
-        representative_samples_do_not_validate: field(content, "representative_samples_do_not_validate"),
-        out_of_scope_backlog: field(content, "out_of_scope_backlog")
-    };
-}
-function parsePlanItems(content) {
-    const items = {};
-    const matches = [...content.matchAll(/\b(PI-\d{3,})\b\s*[:.-]?\s*([^\n]*)/gi)];
-    for (const [index, match] of matches.entries()) {
-        const id = match[1].toUpperCase();
-        const block = blockAfter(content, match.index ?? 0, matches[index + 1]?.index);
-        items[id] = {
-            requirement: cleanText(match[2]) || firstLine(block) || id,
-            delivery_scope: fieldText(block, "delivery_scope"),
-            capability_target: fieldText(block, "capability_target"),
-            representative_samples: field(block, "representative_samples"),
-            full_population_boundary: fieldText(block, "full_population_boundary"),
-            non_required_population: field(block, "non_required_population"),
-            owner_surfaces: field(block, "owner_surfaces"),
-            forbidden_surfaces: field(block, "forbidden_surfaces"),
-            implementation_paths: field(block, "implementation_paths"),
-            required_tests: field(block, "required_tests"),
-            status: "not_started",
-            related_acs: field(block, "related_acs").map((item) => item.toUpperCase()),
-            required_proof_layers: []
-        };
-    }
-    if (Object.keys(items).length === 0) {
-        items["PI-001"] = {
-            requirement: firstLine(content) || "Implement technical realization plan",
-            delivery_scope: "",
-            capability_target: "",
-            representative_samples: [],
-            full_population_boundary: "",
-            non_required_population: [],
-            owner_surfaces: [],
-            forbidden_surfaces: [],
-            implementation_paths: [],
-            required_tests: [],
-            status: "not_started",
-            related_acs: [],
-            required_proof_layers: []
-        };
-    }
-    return items;
-}
-function parseAcceptanceCriteria(content) {
-    const items = {};
-    const matches = [...content.matchAll(/\b(AC-\d{3,})\b\s*[:.-]?\s*([^\n]*)/gi)];
-    for (const [index, match] of matches.entries()) {
-        const id = match[1].toUpperCase();
-        const block = blockAfter(content, match.index ?? 0, matches[index + 1]?.index);
-        const layers = field(block, "required_proof_layers").map(normalizeLayer).filter(Boolean);
-        items[id] = {
-            scope: cleanText(match[2]) || firstLine(block) || id,
-            acceptance_scope: fieldText(block, "acceptance_scope"),
-            ac_validates: field(block, "ac_validates"),
-            ac_does_not_validate: field(block, "ac_does_not_validate"),
-            sample_boundary: fieldText(block, "sample_boundary"),
-            full_population_required: fieldBoolean(block, "full_population_required"),
-            related_plan_items: field(block, "related_plan_items").map((item) => item.toUpperCase()),
-            required_proof_layers: layers.length > 0 ? layers : DEFAULT_LAYERS,
-            status: "not_run"
-        };
-    }
-    if (Object.keys(items).length === 0) {
-        items["AC-001"] = {
-            scope: firstLine(content) || "Acceptance checklist item",
-            acceptance_scope: "",
-            ac_validates: [],
-            ac_does_not_validate: [],
-            sample_boundary: "",
-            full_population_required: null,
-            related_plan_items: [],
-            required_proof_layers: DEFAULT_LAYERS,
-            status: "not_run"
-        };
-    }
-    return items;
-}
 export function computeScopeConflicts(state) {
     const conflicts = [];
     const product = state.delivery?.product_architecture_scope;
     const productScope = product?.delivery_scope ?? "";
-    const productRequiresFullPopulation = productScope === "full_population_operation" || product?.full_population_required === true;
+    const productRequiresFullPopulation = productScope === "full_population_operation";
     const productIsCapabilityOnly = productScope === "system_capability_build" ||
         productScope === "representative_sample_validation" ||
         product?.full_population_required === false;
@@ -187,37 +102,6 @@ function compileProgress(state) {
         }
     };
 }
-function blockAfter(content, start, end) {
-    return content.slice(start, end ?? content.length);
-}
-function field(block, name) {
-    const text = fieldText(block, name);
-    return text ? asStringArray(text) : [];
-}
-function fieldText(block, name) {
-    const pattern = new RegExp(`${name}\\s*:\\s*([^\\n]+)`, "i");
-    const match = pattern.exec(block);
-    return match ? cleanText(match[1]) : "";
-}
-function fieldBoolean(block, name) {
-    const value = fieldText(block, name).toLowerCase();
-    if (value === "true") {
-        return true;
-    }
-    if (value === "false") {
-        return false;
-    }
-    return null;
-}
-function normalizeLayer(value) {
-    return value.trim().toLowerCase().replace(/[- ]+/g, "_");
-}
-function firstLine(content) {
-    return cleanText(content.split(/\r?\n/).find((line) => cleanText(line)) ?? "");
-}
-function cleanText(value) {
-    return value.replace(/^[-#*\s]+/, "").trim();
-}
 function unique(values) {
     return [...new Set(values.filter(Boolean))];
 }

package/dist/lib/superpowers-task-derive.js

@@ -117,7 +117,7 @@ async function assertDerivedJson(workdir, basename, expected, errors) {
     }
     const actual = JSON.parse(await readText(file));
     if (stableJson(actual) !== stableJson(expected)) {
-        errors.push(`derived/${basename}.json does not match task-state.json; rerun ty-context superpowers derive`);
+        errors.push(`derived/${basename}.json does not match task-state.json; rerun ty-context composite-long-task derive`);
     }
 }
 function evidenceForLayers(state, layerIds) {

package/dist/lib/superpowers-task-gates.js

@@ -1,7 +1,7 @@
 import { appendSuperpowersEvent } from "./superpowers-task-events.js";
 import { deriveSuperpowersArtifacts } from "./superpowers-task-derive.js";
 import { loadSuperpowersState, recomputeStatuses, saveSuperpowersState } from "./superpowers-task-state.js";
-import { allCompletionConditionsSatisfied, validateSuperpowersState } from "./superpowers-task-validator.js";
+import { completionConditionErrors, validateSuperpowersState } from "./superpowers-task-validator.js";
 export async function runSliceGate(workdir, sliceId) {
     const state = await loadSuperpowersState(workdir);
     const slice = state.slices.find((item) => item.slice_id === sliceId);
@@ -31,7 +31,9 @@ export async function runFinalGate(workdir) {
     await deriveSuperpowersArtifacts(workdir);
     const report = await validateSuperpowersState(workdir, [workdir]);
     const latest = await loadSuperpowersState(workdir);
-    const complete = report.errors.length === 0 && allCompletionConditionsSatisfied(latest);
+    const completionErrors = completionConditionErrors(latest);
+    const errors = [...new Set([...report.errors, ...completionErrors])];
+    const complete = errors.length === 0;
     latest.final.product_goal_complete = complete;
     latest.meta.product_goal_complete = complete;
     latest.final.acceptance_target_status = complete ? "complete" : "partial";
@@ -39,9 +41,9 @@ export async function runFinalGate(workdir) {
     latest.final.audit_task_complete = true;
     latest.meta.audit_task_complete = true;
     latest.final.completion_basis = complete ? ["all_required_acs_complete", "validator_passed", "auditor_no_blocker"] : [];
-    latest.gates.validator = { status: report.errors.length === 0 ? "pass" : "blocked", errors: report.errors };
+    latest.gates.validator = { status: errors.length === 0 ? "pass" : "blocked", errors };
     await saveSuperpowersState(workdir, latest);
     await deriveSuperpowersArtifacts(workdir);
     await appendSuperpowersEvent(workdir, "final_gate", { product_goal_complete: complete });
-    return { product_goal_complete: complete, errors: report.errors };
+    return { product_goal_complete: complete, errors };
 }

package/dist/lib/superpowers-task-source-compile.d.ts

@@ -0,0 +1,5 @@
+import { type SuperpowersAcceptanceCriterion, type SuperpowersPlanItem, type SuperpowersProductArchitectureScope } from "./superpowers-task-state-schema.js";
+export declare const DEFAULT_LAYERS: string[];
+export declare function parseProductArchitectureScope(content: string, sourceFile: string): SuperpowersProductArchitectureScope;
+export declare function parsePlanItems(content: string, sourceFile: string): Record<string, SuperpowersPlanItem>;
+export declare function parseAcceptanceCriteria(content: string, sourceFile: string): Record<string, SuperpowersAcceptanceCriterion>;