project-tiny-context-harness 0.2.85 → 0.6.1

package/dist/lib/superpowers-task-harness-drift.js

@@ -1,90 +0,0 @@
-import { isRecord } from "./superpowers-task-state-schema.js";
-const HARNESS_PATH_PATTERNS = [
-    /(^|\/)tests\/.*\.(spec|test)\.[cm]?[jt]sx?$/i,
-    /(^|\/)playwright\.config\./i,
-    /(^|\/).*\.spec\.[cm]?[jt]sx?$/i,
-    /(^|\/).*\.test\.[cm]?[jt]sx?$/i,
-    /(^|\/)tests\/ty-context\/fixtures\/composite-long-task\//i,
-    /superpowers-task-(assertions|evidence|evidence-kernel|current-evidence|command-specs|command-run-correlation|unregistered-evidence|completion-output|final-card|ac010|gates|validator|derive|state|state-schema|state-shape|under-specified|protected-baseline|harness-drift)\.ts$/i,
-    /(^|\/)(\.codex\/ty-context-managed|packages\/ty-context\/assets)\/skills\/composite-long-task-workflow\//i,
-    /composite-long-task-workflow-protocol\.md$/i,
-    /(^|\/)Makefile$/i,
-    /(^|\/)package\.json$/i
-];
-const REQUIRED_NEGATIVE_FIXTURES = [
-    "stale_evidence",
-    "historical_complete",
-    "derived_contradiction",
-    "ac010_summary_only",
-    "target_mismatch",
-    "api_only_for_ui",
-    "negative_evidence_after_pass",
-    "source_hash_mismatch",
-    "dirty_worktree_mismatch",
-    "missing_assertion_result",
-    "test_weakening"
-];
-export function detectHarnessDrift(state) {
-    const attempt = currentAttempt(state);
-    const changedFiles = changedFilesFor(attempt);
-    const harnessFiles = changedFiles.filter(isHarnessPath);
-    const mode = attempt?.mode ?? "product_task";
-    if (mode === "product_task" && harnessFiles.length > 0) {
-        return {
-            harness_drift_detected: true,
-            acceptance_target_status: "blocked",
-            product_goal_complete: false,
-            changed_files: harnessFiles,
-            errors: [
-                `harness_drift_detected: ${harnessFiles.join(", ")}`,
-                "本轮修改了验收工具链或测试本身，不能用被修改后的验收证明同一轮产品完成。请拆成独立 harness_task。"
-            ]
-        };
-    }
-    if (mode === "harness_task") {
-        return harnessTaskFixtureVerdict(state, changedFiles);
-    }
-    return { harness_drift_detected: false, acceptance_target_status: "complete", product_goal_complete: true, changed_files: [], errors: [] };
-}
-export function isHarnessPath(file) {
-    const normalized = file.replace(/\\/g, "/");
-    return HARNESS_PATH_PATTERNS.some((pattern) => pattern.test(normalized));
-}
-function harnessTaskFixtureVerdict(state, changedFiles) {
-    const fixtureState = isRecord(state.gates?.harness_task_fixtures) ? state.gates.harness_task_fixtures : undefined;
-    const errors = [];
-    if (!fixtureState) {
-        errors.push("harness_task_missing_adversarial_fixtures: harness_task must declare adversarial fixture outcomes");
-    }
-    else {
-        for (const fixture of REQUIRED_NEGATIVE_FIXTURES) {
-            if (fixtureState[fixture] !== false) {
-                errors.push(`harness_task_missing_adversarial_fixtures: ${fixture} must have expected product_goal_complete=false`);
-            }
-        }
-        if (fixtureState.happy_path !== true) {
-            errors.push("harness_task_missing_happy_path_fixture: happy_path must have expected product_goal_complete=true");
-        }
-    }
-    const fixtureChanges = changedFiles.filter((file) => /(^|\/)tests\/ty-context\/.*fixture/i.test(file.replace(/\\/g, "/")));
-    if (fixtureChanges.length > 0) {
-        errors.push(`fixture_changed_requires_review: ${fixtureChanges.join(", ")}`);
-    }
-    return {
-        harness_drift_detected: false,
-        acceptance_target_status: errors.length > 0 ? "blocked" : "complete",
-        product_goal_complete: false,
-        harness_task_final_verdict: errors.length > 0 ? "failed" : "passed",
-        changed_files: changedFiles,
-        errors
-    };
-}
-function currentAttempt(state) {
-    if (!state.current_attempt_id) {
-        return undefined;
-    }
-    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id);
-}
-function changedFilesFor(attempt) {
-    return [...new Set((attempt?.changed_files ?? []).map((file) => file.replace(/\\/g, "/")).filter(Boolean))];
-}

package/dist/lib/superpowers-task-next-slices.d.ts

@@ -1 +0,0 @@
-export declare function nextSuperpowersSlices(workdir: string, limit?: number): Promise<string[]>;

package/dist/lib/superpowers-task-next-slices.js

@@ -1,12 +0,0 @@
-import { loadSuperpowersState } from "./superpowers-task-state.js";
-export async function nextSuperpowersSlices(workdir, limit = 5) {
-    const state = await loadSuperpowersState(workdir);
-    return Object.entries(state.graph.proof_layers)
-        .filter(([, layer]) => layer.required && layer.status !== "satisfied")
-        .slice(0, limit)
-        .map(([layerId], index) => {
-        const acId = layerId.split(".")[0];
-        const planId = Object.entries(state.graph.plan_items).find(([, item]) => item.related_acs.includes(acId))?.[0] ?? "PI";
-        return `${index + 1}. ${planId}/${acId}: close ${layerId}`;
-    });
-}

package/dist/lib/superpowers-task-protected-baseline.d.ts

@@ -1,10 +0,0 @@
-import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export interface ProtectedBaselineResult {
-    protected_baseline_changed: boolean;
-    product_goal_complete: boolean;
-    changed_files: string[];
-    errors: string[];
-}
-export declare const PROTECTED_BASELINE_PATHS: string[];
-export declare function evaluateProtectedBaseline(state: SuperpowersTaskState): ProtectedBaselineResult;
-export declare function isProtectedBaselinePath(file: string): boolean;

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

@@ -1,66 +0,0 @@
-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-completion-output.ts",
-    "packages/ty-context/src/lib/superpowers-task-final-card.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-current-evidence.ts",
-    "packages/ty-context/src/lib/superpowers-task-command-run-correlation.ts",
-    "packages/ty-context/src/lib/superpowers-task-unregistered-evidence.ts",
-    "packages/ty-context/src/lib/superpowers-task-ac010.ts",
-    "packages/ty-context/src/lib/superpowers-task-harness-drift.ts",
-    "packages/ty-context/src/lib/superpowers-task-protected-baseline.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",
-    ".codex/ty-context-managed/skills/composite-long-task-workflow/assets/goal-objective.template.md",
-    ".codex/ty-context-managed/skills/composite-long-task-workflow/assets/execution-binding.template.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",
-    "packages/ty-context/assets/skills/composite-long-task-workflow/assets/goal-objective.template.md",
-    "packages/ty-context/assets/skills/composite-long-task-workflow/assets/execution-binding.template.md",
-    "tests/ty-context/composite-long-task-completion-output-gate.test.mjs",
-    "tests/ty-context/fixtures/composite-long-task/completion-output-gate/expected-outcomes.json",
-    "tests/ty-context/composite-long-task-false-completion-regression.test.mjs",
-    "tests/ty-context/fixtures/composite-long-task/false-completion-regression/manifest.json"
-];
-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) {
-    if (!state.current_attempt_id) {
-        return undefined;
-    }
-    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id);
-}

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

@@ -1,5 +0,0 @@
-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>;

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

@@ -1,226 +0,0 @@
-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_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_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),
-        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;
-}
-export function parsePlanItems(content, sourceFile) {
-    const items = {};
-    const errors = [];
-    for (const definition of parseHeadingDefinitions(content, { kind: "PI", sourceFile, allowedFields: PLAN_FIELD_SET })) {
-        const fields = definition.fields;
-        items[definition.id] = {
-            requirement: definition.title,
-            source_file: definition.source_file,
-            source_start_line: definition.source_start_line,
-            source_end_line: definition.source_end_line,
-            delivery_scope: requireEnum(errors, definition.id, "delivery_scope", fields, PLAN_DELIVERY_SCOPES, sourceFile, definition.source_start_line),
-            capability_target: requireText(errors, definition.id, "capability_target", fields, sourceFile, definition.source_start_line),
-            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: 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(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",
-            related_acs: optionalArray(fields, "related_acs").map((item) => item.toUpperCase()),
-            required_proof_layers: []
-        };
-    }
-    throwCompileErrors(errors);
-    return items;
-}
-export function parseAcceptanceCriteria(content, sourceFile) {
-    const items = {};
-    const errors = [];
-    for (const definition of parseHeadingDefinitions(content, { kind: "AC", sourceFile, allowedFields: ACCEPTANCE_FIELD_SET })) {
-        const fields = definition.fields;
-        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,
-            source_file: definition.source_file,
-            source_start_line: definition.source_start_line,
-            source_end_line: definition.source_end_line,
-            acceptance_scope: requireEnum(errors, definition.id, "acceptance_scope", fields, ACCEPTANCE_SCOPES, sourceFile, definition.source_start_line),
-            ac_validates: requireArray(errors, definition.id, "ac_validates", fields, sourceFile, definition.source_start_line),
-            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: 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"
-        };
-    }
-    throwCompileErrors(errors);
-    return items;
-}
-function normalizeLayer(value) {
-    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(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: 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
-        };
-    });
-}
-function requireEnum(errors, label, name, fields, allowed, sourceFile, fallbackLine) {
-    const value = fieldText(fields, name);
-    const line = fieldLine(fields, name) ?? fallbackLine;
-    if (!value) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add the required field and rerun compile")}`);
-        return "";
-    }
-    if (!allowed.has(value)) {
-        errors.push(`${label} invalid ${name}: ${value} at ${sourceFile}:${line}; allowed: ${[...allowed].join(", ")}${compileReportSuffix("blocking_unparseable_object", sourceFile, line, name, `value must be one of ${[...allowed].join(", ")}`, "fix the field value and rerun compile")}`);
-    }
-    return value;
-}
-function requireText(errors, label, name, fields, sourceFile, fallbackLine) {
-    const value = fieldText(fields, name);
-    const line = fieldLine(fields, name) ?? fallbackLine;
-    if (!value) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add non-empty text and rerun compile")}`);
-    }
-    return value;
-}
-function requireArray(errors, label, name, fields, sourceFile, fallbackLine) {
-    const line = fieldLine(fields, name) ?? fallbackLine;
-    if (!fields[name]) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add the list field and rerun compile")}`);
-        return [];
-    }
-    return fieldArray(fields, name);
-}
-function requireBoolean(errors, label, name, fields, sourceFile, fallbackLine) {
-    const line = fieldLine(fields, name) ?? fallbackLine;
-    if (!fields[name]) {
-        errors.push(`${label} missing ${name} at ${sourceFile}:${line}${compileReportSuffix(missingCategory(label), sourceFile, line, name, "field is required", "add true or false and rerun compile")}`);
-        return null;
-    }
-    const value = fieldBoolean(fields, name);
-    if (value === null) {
-        errors.push(`${label} invalid ${name}: ${fieldText(fields, name)} at ${sourceFile}:${line}; must be true or false${compileReportSuffix("blocking_unparseable_object", sourceFile, line, name, "value must be true or false", "fix the boolean and rerun compile")}`);
-    }
-    return value;
-}
-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.d.ts

@@ -1,23 +0,0 @@
-export interface ParsedField {
-    value: string | string[];
-    line: number;
-}
-export interface ParsedDefinition {
-    id: string;
-    title: string;
-    fields: Record<string, ParsedField>;
-    source_file: string;
-    source_start_line: number;
-    source_end_line: number;
-}
-export interface DefinitionParseOptions {
-    kind: "PI" | "AC";
-    sourceFile: string;
-    allowedFields: Set<string>;
-}
-export declare function parseHeadingDefinitions(content: string, options: DefinitionParseOptions): ParsedDefinition[];
-export declare function parseDocumentFields(content: string, sourceFile: string, allowedFields: Set<string>): Record<string, ParsedField>;
-export declare function fieldText(fields: Record<string, ParsedField>, name: string): string;
-export declare function fieldArray(fields: Record<string, ParsedField>, name: string): string[];
-export declare function fieldBoolean(fields: Record<string, ParsedField>, name: string): boolean | null;
-export declare function fieldLine(fields: Record<string, ParsedField>, name: string): number | undefined;