project-tiny-context-harness 0.2.81 → 0.2.83

package/dist/lib/superpowers-task-protected-baseline.js

@@ -0,0 +1,47 @@
+import { isHarnessPath } from "./superpowers-task-harness-drift.js";
+import { isRecord } from "./superpowers-task-state-schema.js";
+export const PROTECTED_BASELINE_PATHS = [
+    "packages/ty-context/assets/protected-harness-baseline.json",
+    ".codex/ty-context-managed/protected-harness-baseline.json",
+    "packages/ty-context/source-mappings.yaml",
+    "packages/ty-context/src/lib/superpowers-task-gates.ts",
+    "packages/ty-context/src/lib/superpowers-task-validator.ts",
+    "packages/ty-context/src/lib/superpowers-task-derive.ts",
+    "packages/ty-context/src/lib/superpowers-task-evidence.ts",
+    "packages/ty-context/src/lib/superpowers-task-evidence-kernel.ts",
+    "packages/ty-context/src/lib/superpowers-task-state-schema.ts",
+    ".codex/ty-context-managed/skills/composite-long-task-workflow/SKILL.md",
+    ".codex/ty-context-managed/skills/composite-long-task-workflow/references/composite-long-task-workflow-protocol.md",
+    "packages/ty-context/assets/skills/composite-long-task-workflow/SKILL.md",
+    "packages/ty-context/assets/skills/composite-long-task-workflow/references/composite-long-task-workflow-protocol.md"
+];
+export function evaluateProtectedBaseline(state) {
+    const attempt = currentAttempt(state);
+    const changedFiles = [...new Set((attempt?.changed_files ?? []).map((file) => file.replace(/\\/g, "/")).filter(Boolean))];
+    const protectedChanges = changedFiles.filter(isProtectedBaselinePath);
+    const mode = attempt?.mode ?? "product_task";
+    const errors = [];
+    if (mode === "product_task" && protectedChanges.length > 0) {
+        errors.push(`protected_baseline_changed: product_task cannot change protected harness baseline paths: ${protectedChanges.join(", ")}`);
+    }
+    if (mode === "harness_task" && protectedChanges.length > 0 && !protectedBaselineReason(state)) {
+        errors.push("protected_baseline_reason_required: harness_task baseline changes must record gates.protected_baseline.reason");
+    }
+    return {
+        protected_baseline_changed: protectedChanges.length > 0,
+        product_goal_complete: errors.length === 0,
+        changed_files: protectedChanges,
+        errors
+    };
+}
+export function isProtectedBaselinePath(file) {
+    const normalized = file.replace(/\\/g, "/");
+    return PROTECTED_BASELINE_PATHS.includes(normalized) || isHarnessPath(normalized);
+}
+function protectedBaselineReason(state) {
+    const baseline = state.gates?.protected_baseline;
+    return isRecord(baseline) && typeof baseline.reason === "string" && baseline.reason.trim().length > 0;
+}
+function currentAttempt(state) {
+    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id) ?? (state.attempts ?? []).at(-1);
+}

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

@@ -1,89 +1,38 @@
 import { MACHINE_VERIFIABLE_PROOF_LAYERS, proofLayerName } from "./superpowers-task-assertions.js";
 import { compileReportSuffix, missingCategory, throwCompileErrors } from "./superpowers-task-compile-diagnostics.js";
+import { ACCEPTANCE_FIELDS, ACCEPTANCE_SCOPES, fieldSet, isSelectedScopeFitSlice, normalizeProofLayerName, PLAN_DELIVERY_SCOPES, PLAN_FIELDS, PRODUCT_DELIVERY_SCOPES, PRODUCT_FIELDS, SCOPE_FIT_DECISIONS } from "./superpowers-task-fields.js";
 import { fieldArray, fieldBoolean, fieldLine, fieldText, parseDocumentFields, parseHeadingDefinitions } from "./superpowers-task-source-parser.js";
 export const DEFAULT_LAYERS = ["code", "test"];
-const PRODUCT_DELIVERY_SCOPES = new Set(["system_capability_build", "representative_sample_validation", "full_population_operation", "mixed_scope_requires_boundary"]);
-const PLAN_DELIVERY_SCOPES = new Set(["system_capability_build", "representative_sample_validation", "full_population_operation", "out_of_scope_backlog"]);
-const ACCEPTANCE_SCOPES = new Set(["system_capability_build", "representative_sample_validation", "full_population_operation", "full_population_not_required"]);
-const PRODUCT_FIELDS = new Set([
-    "delivery_scope",
-    "full_population_required",
-    "representative_samples_validate",
-    "representative_samples_do_not_validate",
-    "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",
-    "capability_target",
-    "representative_samples",
-    "full_population_boundary",
-    "non_required_population",
-    "owner_surfaces",
-    "forbidden_surfaces",
-    "implementation_paths",
-    "required_tests",
-    "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",
-    "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"
-]);
+const PRODUCT_FIELD_SET = fieldSet(PRODUCT_FIELDS);
+const PLAN_FIELD_SET = fieldSet(PLAN_FIELDS);
+const ACCEPTANCE_FIELD_SET = fieldSet(ACCEPTANCE_FIELDS);
 export function parseProductArchitectureScope(content, sourceFile) {
-    const fields = parseDocumentFields(content, sourceFile, PRODUCT_FIELDS);
+    const fields = parseDocumentFields(content, sourceFile, PRODUCT_FIELD_SET);
     const errors = [];
+    const selectedScopeFitSlice = requireText(errors, "Product / Architecture Source", "selected_scope_fit_slice", fields, sourceFile, 1);
+    if (selectedScopeFitSlice && !isSelectedScopeFitSlice(selectedScopeFitSlice)) {
+        errors.push(`Product / Architecture Source invalid selected_scope_fit_slice: ${selectedScopeFitSlice} at ${sourceFile}:${fieldLine(fields, "selected_scope_fit_slice") ?? 1}; allowed: none or SFC-###${compileReportSuffix("blocking_unparseable_object", sourceFile, fieldLine(fields, "selected_scope_fit_slice") ?? 1, "selected_scope_fit_slice", "value must be none or an SFC-### id", "fix selected_scope_fit_slice and rerun compile")}`);
+    }
     const scope = {
         delivery_scope: requireEnum(errors, "Product / Architecture Source", "delivery_scope", fields, PRODUCT_DELIVERY_SCOPES, sourceFile, 1),
         full_population_required: requireBoolean(errors, "Product / Architecture Source", "full_population_required", fields, sourceFile, 1),
         representative_samples_validate: requireArray(errors, "Product / Architecture Source", "representative_samples_validate", fields, sourceFile, 1),
         representative_samples_do_not_validate: requireArray(errors, "Product / Architecture Source", "representative_samples_do_not_validate", fields, sourceFile, 1),
-        out_of_scope_backlog: requireArray(errors, "Product / Architecture Source", "out_of_scope_backlog", fields, sourceFile, 1)
+        out_of_scope_backlog: requireArray(errors, "Product / Architecture Source", "out_of_scope_backlog", fields, sourceFile, 1),
+        scope_fit_decision: requireEnum(errors, "Product / Architecture Source", "scope_fit_decision", fields, SCOPE_FIT_DECISIONS, sourceFile, 1),
+        selected_scope_fit_slice: selectedScopeFitSlice,
+        owner_boundary: requireText(errors, "Product / Architecture Source", "owner_boundary", fields, sourceFile, 1),
+        primary_capability_path: requireText(errors, "Product / Architecture Source", "primary_capability_path", fields, sourceFile, 1),
+        non_completing_outcomes: requireArray(errors, "Product / Architecture Source", "non_completing_outcomes", fields, sourceFile, 1),
+        assertion_policy: requireText(errors, "Product / Architecture Source", "assertion_policy", fields, sourceFile, 1),
+        source_authority: requireText(errors, "Product / Architecture Source", "source_authority", fields, sourceFile, 1),
+        product_goal: requireText(errors, "Product / Architecture Source", "product_goal", fields, sourceFile, 1),
+        surface_ia_lock: optionalText(fields, "surface_ia_lock"),
+        decision_lock: optionalText(fields, "decision_lock"),
+        context_delta: optionalText(fields, "context_delta"),
+        source_to_context_coverage: optionalText(fields, "source_to_context_coverage"),
+        acceptance_semantics: optionalText(fields, "acceptance_semantics"),
+        impact: optionalText(fields, "impact")
     };
     throwCompileErrors(errors);
     return scope;
@@ -91,7 +40,7 @@ export function parseProductArchitectureScope(content, sourceFile) {
 export function parsePlanItems(content, sourceFile) {
     const items = {};
     const errors = [];
-    for (const definition of parseHeadingDefinitions(content, { kind: "PI", sourceFile, allowedFields: PLAN_FIELDS })) {
+    for (const definition of parseHeadingDefinitions(content, { kind: "PI", sourceFile, allowedFields: PLAN_FIELD_SET })) {
         const fields = definition.fields;
         items[definition.id] = {
             requirement: definition.title,
@@ -103,13 +52,33 @@ export function parsePlanItems(content, sourceFile) {
             representative_samples: requireArray(errors, definition.id, "representative_samples", fields, sourceFile, definition.source_start_line),
             full_population_boundary: requireText(errors, definition.id, "full_population_boundary", fields, sourceFile, definition.source_start_line),
             non_required_population: requireArray(errors, definition.id, "non_required_population", fields, sourceFile, definition.source_start_line),
+            owner_boundary: requireText(errors, definition.id, "owner_boundary", fields, sourceFile, definition.source_start_line),
+            primary_capability_path: requireText(errors, definition.id, "primary_capability_path", fields, sourceFile, definition.source_start_line),
+            trigger_contract: requireText(errors, definition.id, "trigger_contract", fields, sourceFile, definition.source_start_line),
+            state_transition_contract: requireText(errors, definition.id, "state_transition_contract", fields, sourceFile, definition.source_start_line),
+            observable_result_contract: requireText(errors, definition.id, "observable_result_contract", fields, sourceFile, definition.source_start_line),
+            assertion_support: requireText(errors, definition.id, "assertion_support", fields, sourceFile, definition.source_start_line),
+            required_assertion_commands: requireArray(errors, definition.id, "required_assertion_commands", fields, sourceFile, definition.source_start_line),
+            invalid_implementation_shortcuts: requireArray(errors, definition.id, "invalid_implementation_shortcuts", fields, sourceFile, definition.source_start_line),
             owner_surfaces: optionalArray(fields, "owner_surfaces"),
             forbidden_surfaces: optionalArray(fields, "forbidden_surfaces"),
-            implementation_paths: optionalArray(fields, "implementation_paths"),
+            implementation_paths: requireArray(errors, definition.id, "implementation_paths", fields, sourceFile, definition.source_start_line),
             required_tests: optionalArray(fields, "required_tests"),
-            proof_layer_ids: optionalArray(fields, "proof_layer_ids").map(normalizeLayer),
+            proof_layer_ids: optionalArray(fields, "proof_layer_ids").map(normalizeLayerId),
+            requirement_ref: optionalText(fields, "requirement_ref"),
+            decision_id: optionalText(fields, "decision_id"),
+            api_schema_changes: optionalText(fields, "api_schema_changes"),
+            state_machine: optionalText(fields, "state_machine"),
+            data_flow: optionalText(fields, "data_flow"),
+            worker_runtime_behavior: optionalText(fields, "worker_runtime_behavior"),
+            ui_ia_changes: optionalText(fields, "ui_ia_changes"),
+            migration_plan: optionalText(fields, "migration_plan"),
+            evidence_artifacts: optionalArray(fields, "evidence_artifacts"),
             non_completing_shortcuts: optionalArray(fields, "non_completing_shortcuts"),
             substitution_policy: optionalArray(fields, "substitution_policy"),
+            drift_severity: optionalText(fields, "drift_severity"),
+            partial_conditions: optionalArray(fields, "partial_conditions"),
+            blockers: optionalArray(fields, "blockers"),
             explicit_no_test_scope: fieldBoolean(fields, "explicit_no_test_scope") === true,
             context_fact_refs: optionalArray(fields, "context_fact_refs"),
             status: "not_started",
@@ -123,9 +92,9 @@ export function parsePlanItems(content, sourceFile) {
 export function parseAcceptanceCriteria(content, sourceFile) {
     const items = {};
     const errors = [];
-    for (const definition of parseHeadingDefinitions(content, { kind: "AC", sourceFile, allowedFields: ACCEPTANCE_FIELDS })) {
+    for (const definition of parseHeadingDefinitions(content, { kind: "AC", sourceFile, allowedFields: ACCEPTANCE_FIELD_SET })) {
         const fields = definition.fields;
-        const layers = optionalArray(fields, "required_proof_layers").map(normalizeLayer).filter(Boolean);
+        const layers = requireArray(errors, definition.id, "required_proof_layers", fields, sourceFile, definition.source_start_line).map(normalizeLayer).filter(Boolean);
         const requiredProofLayers = layers.length > 0 ? layers : DEFAULT_LAYERS;
         items[definition.id] = {
             scope: definition.title,
@@ -137,13 +106,31 @@ export function parseAcceptanceCriteria(content, sourceFile) {
             ac_does_not_validate: requireArray(errors, definition.id, "ac_does_not_validate", fields, sourceFile, definition.source_start_line),
             sample_boundary: requireText(errors, definition.id, "sample_boundary", fields, sourceFile, definition.source_start_line),
             full_population_required: requireBoolean(errors, definition.id, "full_population_required", fields, sourceFile, definition.source_start_line),
-            related_plan_items: optionalArray(fields, "related_plan_items").map((item) => item.toUpperCase()),
+            related_plan_items: requireArray(errors, definition.id, "related_plan_items", fields, sourceFile, definition.source_start_line).map((item) => item.toUpperCase()),
             required_proof_layers: requiredProofLayers,
             assertion_requirements: assertionRequirements(fields, requiredProofLayers),
+            assertion_command: requireText(errors, definition.id, "assertion_command", fields, sourceFile, definition.source_start_line),
+            assertion_artifacts: requireArray(errors, definition.id, "assertion_artifacts", fields, sourceFile, definition.source_start_line),
+            positive_assertions: requireArray(errors, definition.id, "positive_assertions", fields, sourceFile, definition.source_start_line),
+            negative_assertions: requireArray(errors, definition.id, "negative_assertions", fields, sourceFile, definition.source_start_line),
+            machine_blocking: requireBoolean(errors, definition.id, "machine_blocking", fields, sourceFile, definition.source_start_line),
+            invalid_completion_signals: requireArray(errors, definition.id, "invalid_completion_signals", fields, sourceFile, definition.source_start_line),
+            assertion_result_required: requireBoolean(errors, definition.id, "assertion_result_required", fields, sourceFile, definition.source_start_line),
+            ac_type: optionalText(fields, "ac_type"),
+            proof_chain: optionalArray(fields, "proof_chain").map(normalizeLayerId),
             required_test_ids: optionalArray(fields, "required_test_ids"),
             fail_conditions: optionalArray(fields, "fail_conditions"),
             invalid_evidence: optionalArray(fields, "invalid_evidence"),
+            substitution_policy: optionalArray(fields, "substitution_policy"),
+            missing_layer_downgrade: optionalText(fields, "missing_layer_downgrade"),
+            auditor_expectation: optionalText(fields, "auditor_expectation"),
+            out_of_scope_na_approval_source: optionalText(fields, "out_of_scope_na_approval_source"),
+            hard_blockers: optionalArray(fields, "hard_blockers"),
+            validates_explanation: optionalText(fields, "validates_explanation"),
+            does_not_validate_explanation: optionalText(fields, "does_not_validate_explanation"),
             final_evidence_expected: optionalArray(fields, "final_evidence_expected"),
+            verification_method: optionalArray(fields, "verification_method"),
+            test_cases: optionalArray(fields, "test_cases"),
             explicit_no_test_scope: fieldBoolean(fields, "explicit_no_test_scope") === true,
             status: "not_run"
         };
@@ -152,28 +139,36 @@ export function parseAcceptanceCriteria(content, sourceFile) {
     return items;
 }
 function normalizeLayer(value) {
-    return value.trim().toLowerCase().replace(/[- ]+/g, "_");
+    return normalizeProofLayerName(value);
+}
+function normalizeLayerId(value) {
+    const trimmed = value.trim();
+    if (!trimmed.includes(".")) {
+        return normalizeLayer(trimmed);
+    }
+    const acId = trimmed.slice(0, trimmed.lastIndexOf(".")).toUpperCase();
+    const layer = trimmed.slice(trimmed.lastIndexOf(".") + 1);
+    return `${acId}.${normalizeLayer(layer)}`;
 }
 function assertionRequirements(fields, layers) {
     const requiredTestIds = optionalArray(fields, "required_test_ids");
-    const positiveAssertions = unique([
-        ...fieldArray(fields, "ac_validates"),
-        ...requiredTestIds,
-        ...optionalArray(fields, "test_cases"),
-        ...optionalArray(fields, "verification_method"),
-        ...optionalArray(fields, "final_evidence_expected")
-    ]);
-    const negativeAssertions = unique([
-        ...fieldArray(fields, "ac_does_not_validate"),
-        ...optionalArray(fields, "fail_conditions"),
-        ...optionalArray(fields, "invalid_evidence")
-    ]);
+    const positiveAssertions = unique(optionalArray(fields, "positive_assertions"));
+    const negativeAssertions = unique(optionalArray(fields, "negative_assertions"));
+    const assertionCommand = fieldText(fields, "assertion_command");
+    const assertionArtifacts = optionalArray(fields, "assertion_artifacts");
+    const machineBlocking = fieldBoolean(fields, "machine_blocking");
+    const assertionResultRequired = fieldBoolean(fields, "assertion_result_required");
+    const invalidCompletionSignals = optionalArray(fields, "invalid_completion_signals");
     return layers.map((layer) => {
         const normalized = proofLayerName(normalizeLayer(layer));
         return {
             proof_layer: normalized,
             required: true,
-            machine_blocking: MACHINE_VERIFIABLE_PROOF_LAYERS.has(normalized),
+            machine_blocking: machineBlocking ?? MACHINE_VERIFIABLE_PROOF_LAYERS.has(normalized),
+            assertion_result_required: assertionResultRequired ?? MACHINE_VERIFIABLE_PROOF_LAYERS.has(normalized),
+            assertion_command: assertionCommand,
+            assertion_artifacts: assertionArtifacts,
+            invalid_completion_signals: invalidCompletionSignals,
             required_test_ids: requiredTestIds,
             positive_assertions: positiveAssertions,
             negative_assertions: negativeAssertions
@@ -223,6 +218,9 @@ function requireBoolean(errors, label, name, fields, sourceFile, fallbackLine) {
 function optionalArray(fields, name) {
     return fields[name] ? fieldArray(fields, name) : [];
 }
+function optionalText(fields, name) {
+    return fields[name] ? fieldText(fields, name) : "";
+}
 function unique(values) {
     return [...new Set(values.filter(Boolean))];
 }

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

@@ -86,9 +86,7 @@ function parseFields(lines, sourceFile, startLine, allowedFields, errors) {
         }
         const name = match[1];
         if (!allowedFields.has(name)) {
-            if (name.includes("_")) {
-                errors.push(compileError(`${sourceFile}:${lineNumber} unknown field ${name}`, "blocking_unparseable_object", sourceFile, lineNumber, name, "unknown fields may hide required source semantics", "rename the field to a supported canonical key"));
-            }
+            errors.push(compileError(`${sourceFile}:${lineNumber} unknown field ${name}`, "blocking_unparseable_object", sourceFile, lineNumber, name, "unknown fields may hide required source semantics", "rename the field to a supported canonical key"));
             continue;
         }
         if (fields[name]) {

package/dist/lib/superpowers-task-state-schema.d.ts

@@ -4,7 +4,7 @@ export declare const SUPERPOWERS_TASK_STATE_JSON_SCHEMA: {
     readonly $id: "https://project-tiny-context-harness.local/superpowers-task-state.schema.json";
     readonly title: "Superpowers Long-Task State";
     readonly type: "object";
-    readonly required: readonly ["meta", "sources", "context", "delivery", "graph", "slices", "evidence", "gates", "progress", "blockers", "final"];
+    readonly required: readonly ["meta", "sources", "context", "delivery", "graph", "attempts", "current_attempt_id", "required_command_specs", "command_runs", "negative_evidence_records", "slices", "evidence", "gates", "progress", "blockers", "final"];
     readonly properties: {
         readonly meta: {
             readonly type: "object";
@@ -33,6 +33,21 @@ export declare const SUPERPOWERS_TASK_STATE_JSON_SCHEMA: {
         readonly graph: {
             readonly type: "object";
         };
+        readonly attempts: {
+            readonly type: "array";
+        };
+        readonly current_attempt_id: {
+            readonly type: "string";
+        };
+        readonly required_command_specs: {
+            readonly type: "array";
+        };
+        readonly command_runs: {
+            readonly type: "array";
+        };
+        readonly negative_evidence_records: {
+            readonly type: "array";
+        };
         readonly slices: {
             readonly type: "array";
         };
@@ -55,10 +70,12 @@ export declare const SUPERPOWERS_TASK_STATE_JSON_SCHEMA: {
 };
 export type SuperpowersProofLayerStatus = "missing" | "satisfied" | "invalidated" | "blocked";
 export type SuperpowersPlanItemStatus = "not_started" | "in_progress" | "complete" | "partial" | "blocked" | "invalidated" | "out_of_scope_NA";
-export type SuperpowersAcceptanceStatus = "not_run" | "complete" | "partial" | "blocked" | "invalidated" | "out_of_scope_NA";
+export type SuperpowersAcceptanceStatus = "not_run" | "complete" | "partial" | "blocked" | "invalidated" | "under_specified" | "out_of_scope_NA";
+export type SuperpowersAttemptMode = "product_task" | "harness_task";
 export type SuperpowersProductDeliveryScope = "system_capability_build" | "representative_sample_validation" | "full_population_operation" | "mixed_scope_requires_boundary";
 export type SuperpowersPlanDeliveryScope = "system_capability_build" | "representative_sample_validation" | "full_population_operation" | "out_of_scope_backlog";
 export type SuperpowersAcceptanceScope = "system_capability_build" | "representative_sample_validation" | "full_population_operation" | "full_population_not_required";
+export type SuperpowersScopeFitDecision = "fit_for_three_inputs" | "selected_from_split" | "blocked_for_decision" | "";
 export interface SuperpowersTaskState {
     meta: {
         task_id: string;
@@ -85,6 +102,11 @@ export interface SuperpowersTaskState {
         proof_layers: Record<string, SuperpowersProofLayer>;
         edges: SuperpowersGraphEdge[];
     };
+    attempts: ExecutionAttempt[];
+    current_attempt_id: string;
+    required_command_specs: RequiredCommandSpec[];
+    command_runs: CommandRunRecord[];
+    negative_evidence_records: NegativeEvidenceRecord[];
     slices: SuperpowersSliceRecord[];
     evidence: SuperpowersEvidenceRecord[];
     gates: Record<string, unknown>;
@@ -98,6 +120,60 @@ export interface SuperpowersTaskState {
         next_required_actions?: string[];
     };
 }
+export interface ExecutionAttempt {
+    task_attempt_id: string;
+    source_bundle_hash: string;
+    product_source_hash: string;
+    technical_plan_hash: string;
+    acceptance_checklist_hash: string;
+    git_head: string;
+    git_status_short: string;
+    tracked_diff_hash: string;
+    relevant_untracked_hash: string;
+    untracked_relevant_hash?: string;
+    worktree_fingerprint: string;
+    started_at: string;
+    ended_at: string | null;
+    finalized_at?: string | null;
+    required_command_specs_hash: string;
+    mode: SuperpowersAttemptMode;
+    changed_files?: string[];
+}
+export interface RequiredCommandSpec {
+    command_spec_id: string;
+    ac_id: string;
+    proof_layers: string[];
+    command: string;
+    assertion_artifacts: string[];
+    required_test_ids: string[];
+    machine_blocking: boolean;
+    assertion_result_required: boolean;
+    positive_assertions: string[];
+    negative_assertions: string[];
+    invalid_completion_signals: string[];
+    final_evidence_expected: string[];
+}
+export interface CommandRunRecord {
+    command_run_id: string;
+    task_attempt_id: string;
+    command_spec_id: string;
+    ac_id: string;
+    proof_layer: string;
+    command_line: string;
+    exit_code: number;
+    started_at: string;
+    ended_at: string;
+    artifact_paths: string[];
+}
+export interface NegativeEvidenceRecord {
+    negative_evidence_id: string;
+    task_attempt_id: string;
+    target_ac_ids: string[];
+    target_proof_layers: string[];
+    artifact_path: string;
+    artifact_sha256?: string;
+    status: "passed" | "failed" | "blocked" | "stale";
+}
 export interface SuperpowersSourceRecord {
     path: string;
     sha256: string;
@@ -113,6 +189,20 @@ export interface SuperpowersProductArchitectureScope {
     representative_samples_validate: string[];
     representative_samples_do_not_validate: string[];
     out_of_scope_backlog: string[];
+    scope_fit_decision: SuperpowersScopeFitDecision;
+    selected_scope_fit_slice: string;
+    owner_boundary: string;
+    primary_capability_path: string;
+    non_completing_outcomes: string[];
+    assertion_policy: string;
+    source_authority: string;
+    product_goal: string;
+    surface_ia_lock?: string;
+    decision_lock?: string;
+    context_delta?: string;
+    source_to_context_coverage?: string;
+    acceptance_semantics?: string;
+    impact?: string;
 }
 export interface SuperpowersProgressState {
     system_capability_progress: Record<string, unknown>;
@@ -131,13 +221,33 @@ export interface SuperpowersPlanItem {
     representative_samples: string[];
     full_population_boundary: string;
     non_required_population: string[];
+    owner_boundary: string;
+    primary_capability_path: string;
+    trigger_contract: string;
+    state_transition_contract: string;
+    observable_result_contract: string;
+    assertion_support: string;
+    required_assertion_commands: string[];
+    invalid_implementation_shortcuts: string[];
     owner_surfaces: string[];
     forbidden_surfaces: string[];
     implementation_paths: string[];
     required_tests: string[];
     proof_layer_ids?: string[];
+    requirement_ref?: string;
+    decision_id?: string;
+    api_schema_changes?: string;
+    state_machine?: string;
+    data_flow?: string;
+    worker_runtime_behavior?: string;
+    ui_ia_changes?: string;
+    migration_plan?: string;
+    evidence_artifacts?: string[];
     non_completing_shortcuts?: string[];
     substitution_policy?: string[];
+    drift_severity?: string;
+    partial_conditions?: string[];
+    blockers?: string[];
     explicit_no_test_scope?: boolean;
     context_fact_refs?: string[];
     status: SuperpowersPlanItemStatus;
@@ -157,10 +267,28 @@ export interface SuperpowersAcceptanceCriterion {
     related_plan_items: string[];
     required_proof_layers: string[];
     assertion_requirements?: AssertionRequirement[];
+    assertion_command?: string;
+    assertion_artifacts?: string[];
+    positive_assertions?: string[];
+    negative_assertions?: string[];
+    machine_blocking?: boolean | null;
+    invalid_completion_signals?: string[];
+    assertion_result_required?: boolean | null;
+    ac_type?: string;
+    proof_chain?: string[];
     required_test_ids?: string[];
     fail_conditions?: string[];
     invalid_evidence?: string[];
+    substitution_policy?: string[];
+    missing_layer_downgrade?: string;
+    auditor_expectation?: string;
+    out_of_scope_na_approval_source?: string;
+    hard_blockers?: string[];
+    validates_explanation?: string;
+    does_not_validate_explanation?: string;
     final_evidence_expected?: string[];
+    verification_method?: string[];
+    test_cases?: string[];
     explicit_no_test_scope?: boolean;
     status: SuperpowersAcceptanceStatus;
 }
@@ -168,6 +296,10 @@ export interface AssertionRequirement {
     proof_layer: string;
     required: boolean;
     machine_blocking: boolean;
+    assertion_result_required?: boolean;
+    assertion_command?: string;
+    assertion_artifacts?: string[];
+    invalid_completion_signals?: string[];
     required_test_ids: string[];
     positive_assertions: string[];
     negative_assertions: string[];
@@ -201,7 +333,24 @@ export interface SuperpowersSliceRecord {
     };
 }
 export interface SuperpowersEvidenceRecord {
+    schema_version?: "evidence-record-v1" | "evidence-record-v2" | string;
     evidence_id: string;
+    task_attempt_id?: string;
+    source_bundle_hash?: string;
+    product_source_hash?: string;
+    technical_plan_hash?: string;
+    acceptance_checklist_hash?: string;
+    git_head?: string;
+    worktree_fingerprint?: string;
+    command_spec_id?: string;
+    command_run_id?: string;
+    command_line?: string;
+    artifact_path?: string;
+    artifact_sha256?: string;
+    artifact_mtime?: string;
+    target_ac_ids?: string[];
+    target_pi_ids?: string[];
+    target_proof_layers?: string[];
     slice_id: string;
     type: string;
     freshness: {
@@ -228,17 +377,21 @@ export interface SuperpowersEvidenceRecord {
     sibling_substitution_approval_source?: string;
 }
 export interface AssertionResult {
-    schema_version: "assertion-result-v1";
+    schema_version: "assertion-result-v1" | "assertion-result-v2";
     status: "passed" | "failed" | "blocked" | "stale";
     runner: string;
     exit_code: number;
     target_ac_ids: string[];
+    target_pi_ids?: string[];
     target_proof_layers: string[];
     owner_surface?: string;
     route?: string;
     action?: string;
     positive_assertions: AssertionCheck[];
     negative_assertions: AssertionCheck[];
+    invalid_completion_signals?: AssertionCheck[];
+    negative_evidence_scan?: NegativeEvidenceScan;
+    required_test_ids?: string[];
     artifacts?: string[];
 }
 export interface AssertionCheck {
@@ -252,6 +405,8 @@ export interface NegativeEvidenceScan {
     schema_version: "negative-evidence-scan-v1";
     status: "passed" | "failed" | "blocked" | "stale";
     target_ac_ids: string[];
+    target_proof_layers?: string[];
+    invalid_completion_signals_checked?: string[];
     owner_surface?: string;
     route?: string;
     forbidden_findings: NegativeFinding[];

package/dist/lib/superpowers-task-state-schema.js

@@ -4,7 +4,24 @@ export const SUPERPOWERS_TASK_STATE_JSON_SCHEMA = {
     $id: "https://project-tiny-context-harness.local/superpowers-task-state.schema.json",
     title: "Superpowers Long-Task State",
     type: "object",
-    required: ["meta", "sources", "context", "delivery", "graph", "slices", "evidence", "gates", "progress", "blockers", "final"],
+    required: [
+        "meta",
+        "sources",
+        "context",
+        "delivery",
+        "graph",
+        "attempts",
+        "current_attempt_id",
+        "required_command_specs",
+        "command_runs",
+        "negative_evidence_records",
+        "slices",
+        "evidence",
+        "gates",
+        "progress",
+        "blockers",
+        "final"
+    ],
     properties: {
         meta: {
             type: "object",
@@ -19,6 +36,11 @@ export const SUPERPOWERS_TASK_STATE_JSON_SCHEMA = {
         context: { type: "object" },
         delivery: { type: "object" },
         graph: { type: "object" },
+        attempts: { type: "array" },
+        current_attempt_id: { type: "string" },
+        required_command_specs: { type: "array" },
+        command_runs: { type: "array" },
+        negative_evidence_records: { type: "array" },
         slices: { type: "array" },
         evidence: { type: "array" },
         gates: { type: "object" },

package/dist/lib/superpowers-task-state-shape.d.ts

@@ -0,0 +1,3 @@
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export declare function validateShape(state: SuperpowersTaskState, errors: string[]): void;
+export declare function hasUsableShape(state: SuperpowersTaskState): boolean;