project-tiny-context-harness 0.2.79 → 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

@@ -50,7 +50,7 @@ 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;

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.js

@@ -8,7 +8,15 @@ const PRODUCT_FIELDS = new Set([
     "full_population_required",
     "representative_samples_validate",
     "representative_samples_do_not_validate",
-    "out_of_scope_backlog"
+    "out_of_scope_backlog",
+    "source_authority",
+    "product_goal",
+    "surface_ia_lock",
+    "decision_lock",
+    "context_delta",
+    "source_to_context_coverage",
+    "acceptance_semantics",
+    "impact"
 ]);
 const PLAN_FIELDS = new Set([
     "delivery_scope",
@@ -20,16 +28,50 @@ const PLAN_FIELDS = new Set([
     "forbidden_surfaces",
     "implementation_paths",
     "required_tests",
-    "related_acs"
+    "related_acs",
+    "requirement_ref",
+    "decision_id",
+    "proof_layer_ids",
+    "api_schema_changes",
+    "state_machine",
+    "data_flow",
+    "worker_runtime_behavior",
+    "ui_ia_changes",
+    "migration_plan",
+    "evidence_artifacts",
+    "explicit_no_test_scope",
+    "non_completing_shortcuts",
+    "substitution_policy",
+    "drift_severity",
+    "partial_conditions",
+    "blockers",
+    "context_fact_refs"
 ]);
 const ACCEPTANCE_FIELDS = new Set([
+    "checklist_source",
     "acceptance_scope",
     "ac_validates",
     "ac_does_not_validate",
     "sample_boundary",
     "full_population_required",
     "related_plan_items",
-    "required_proof_layers"
+    "required_proof_layers",
+    "ac_type",
+    "proof_chain",
+    "verification_method",
+    "fail_conditions",
+    "invalid_evidence",
+    "substitution_policy",
+    "missing_layer_downgrade",
+    "auditor_expectation",
+    "out_of_scope_na_approval_source",
+    "required_test_ids",
+    "explicit_no_test_scope",
+    "hard_blockers",
+    "validates_explanation",
+    "does_not_validate_explanation",
+    "final_evidence_expected",
+    "test_cases"
 ]);
 export function parseProductArchitectureScope(content, sourceFile) {
     const fields = parseDocumentFields(content, sourceFile, PRODUCT_FIELDS);

package/dist/lib/superpowers-task-source-parser.js

@@ -107,7 +107,7 @@ function parseFieldValue(lines, index, rest, sourceFile, lineNumber, errors) {
         let cursor = index + 1;
         for (; cursor < lines.length; cursor++) {
             const next = lines[cursor];
-            if (next.trim() && !/^\s/.test(next)) {
+            if (next.trim() && isTopLevelFieldOrHeading(next)) {
                 break;
             }
             block.push(next.replace(/^\s{0,2}/, ""));
@@ -127,7 +127,7 @@ function parseFieldValue(lines, index, rest, sourceFile, lineNumber, errors) {
         if (!next.trim()) {
             continue;
         }
-        if (!/^\s/.test(next)) {
+        if (isTopLevelFieldOrHeading(next)) {
             break;
         }
         const listItem = /^\s*[-*+]\s+(.+?)\s*$/.exec(next);
@@ -139,6 +139,12 @@ function parseFieldValue(lines, index, rest, sourceFile, lineNumber, errors) {
     }
     return { value: values, endIndex: cursor - 1 };
 }
+function isTopLevelFieldOrHeading(line) {
+    if (/^(#{1,6})\s+/.test(line)) {
+        return true;
+    }
+    return /^([a-z][a-z0-9_]*)\s*:/.test(line);
+}
 function rejectListStyleDefinitions(lines, options, errors) {
     const idPattern = options.kind === "PI" ? "PI" : "AC";
     const listPattern = new RegExp(`^\\s*[-*+]\\s+(${idPattern}-\\d{3,})\\b\\s*[:.-]?`, "i");

package/dist/lib/superpowers-task-validator.d.ts

@@ -1,4 +1,5 @@
 import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
 import type { ValidatorReport } from "./validators.js";
 export declare function validateSuperpowersState(projectRoot: string, args?: string[]): Promise<ValidatorReport>;
+export declare function completionConditionErrors(state: SuperpowersTaskState): string[];
 export declare function allCompletionConditionsSatisfied(state: SuperpowersTaskState): boolean;

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

@@ -221,6 +221,9 @@ function validateFinalCompletion(state, errors) {
             errors.push("product_goal_complete=true but Context Delta coverage is unresolved");
         }
     }
+    validateFullPopulationEvidence(state, errors);
+}
+function validateFullPopulationEvidence(state, errors) {
     if (fullPopulationRequired(state)) {
         const sampleOnlyEvidence = state.evidence.filter((evidence) => evidence.does_not_prove.some((claim) => /\b(full[-_ ]?population|all[-_ ]?provider|all[-_ ]?interface|all[-_ ]?platform)\b/i.test(claim)));
         if (sampleOnlyEvidence.length > 0) {
@@ -230,11 +233,11 @@ function validateFinalCompletion(state, errors) {
         }
     }
 }
-export function allCompletionConditionsSatisfied(state) {
+export function completionConditionErrors(state) {
     const errors = [];
     validateShape(state, errors);
     if (!hasUsableShape(state)) {
-        return false;
+        return errors;
     }
     validateDeliveryContract(state, errors);
     validateScopeConflicts(state, errors);
@@ -242,11 +245,21 @@ export function allCompletionConditionsSatisfied(state) {
     validateEvidenceRecords(state, errors);
     validateProofLayers(state, errors);
     validateAuditor(state, errors);
+    validateFullPopulationEvidence(state, errors);
     const planItems = Object.values(state.graph.plan_items);
     const acceptanceCriteria = Object.values(state.graph.acceptance_criteria);
     const proofLayers = Object.values(state.graph.proof_layers);
     const allPlansComplete = planItems.every((item) => item.status === "complete" || item.status === "out_of_scope_NA");
     const allAcsComplete = acceptanceCriteria.every((ac) => ac.status === "complete" || ac.status === "out_of_scope_NA");
     const allLayersSatisfied = proofLayers.every((layer) => !layer.required || layer.status === "satisfied");
-    return errors.length === 0 && planItems.length > 0 && acceptanceCriteria.length > 0 && proofLayers.length > 0 && allPlansComplete && allAcsComplete && allLayersSatisfied;
+    if (planItems.length === 0 || acceptanceCriteria.length === 0 || proofLayers.length === 0) {
+        errors.push("completion conditions require a compiled task graph with plan items, ACs and proof layers");
+    }
+    if (!allPlansComplete || !allAcsComplete || !allLayersSatisfied) {
+        errors.push("completion conditions require all required plan items, ACs and proof layers to be complete");
+    }
+    return errors;
+}
+export function allCompletionConditionsSatisfied(state) {
+    return completionConditionErrors(state).length === 0;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-tiny-context-harness",
-  "version": "0.2.79",
+  "version": "0.2.80",
   "description": "Minimal project memory and validation harness for AI coding agents.",
   "license": "MIT",
   "author": "Seven128",