project-tiny-context-harness 0.2.85 → 0.6.1

package/dist/lib/superpowers-task-current-evidence.js

@@ -1,176 +0,0 @@
-import { createHash } from "node:crypto";
-import path from "node:path";
-import { pathExists, readText } from "./fs.js";
-import { normalizeProofLayerName } from "./superpowers-task-fields.js";
-export function evaluateCurrentAttemptEvidence(state, evidence, layerId) {
-    if (!state.current_attempt_id) {
-        return [];
-    }
-    const failures = [];
-    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
-    if (evidence.schema_version !== "evidence-record-v2") {
-        failures.push(`${label} must be EvidenceRecordV2 for current-attempt machine completion`);
-    }
-    if (evidence.task_attempt_id !== state.current_attempt_id) {
-        failures.push(`${label} stale evidence from old attempt ${evidence.task_attempt_id || "(missing)"}; expected current attempt ${state.current_attempt_id}`);
-    }
-    for (const field of [
-        "generated_at",
-        "source_bundle_hash",
-        "product_source_hash",
-        "technical_plan_hash",
-        "acceptance_checklist_hash",
-        "git_head",
-        "git_status_short",
-        "tracked_diff_hash",
-        "relevant_untracked_hash",
-        "worktree_fingerprint",
-        "command_spec_id",
-        "command_run_id",
-        "command_line",
-        "artifact_path",
-        "artifact_sha256",
-        "artifact_mtime"
-    ]) {
-        if (!evidence[field]) {
-            failures.push(`${label} EvidenceRecordV2 missing ${field}`);
-        }
-    }
-    const attempt = state.attempts?.find((item) => item.task_attempt_id === state.current_attempt_id);
-    if (attempt && evidence.source_bundle_hash && evidence.source_bundle_hash !== attempt.source_bundle_hash) {
-        failures.push(`${label} stale evidence source_bundle_hash mismatch for current attempt`);
-    }
-    if (attempt && evidence.product_source_hash && evidence.product_source_hash !== attempt.product_source_hash) {
-        failures.push(`${label} stale evidence product_source_hash mismatch for current attempt`);
-    }
-    if (attempt && evidence.technical_plan_hash && evidence.technical_plan_hash !== attempt.technical_plan_hash) {
-        failures.push(`${label} stale evidence technical_plan_hash mismatch for current attempt`);
-    }
-    if (attempt && evidence.acceptance_checklist_hash && evidence.acceptance_checklist_hash !== attempt.acceptance_checklist_hash) {
-        failures.push(`${label} stale evidence acceptance_checklist_hash mismatch for current attempt`);
-    }
-    if (attempt && evidence.git_head && evidence.git_head !== attempt.git_head) {
-        failures.push(`${label} stale evidence git_head mismatch for current attempt`);
-    }
-    if (attempt && evidence.git_status_short !== undefined && evidence.git_status_short !== attempt.git_status_short) {
-        failures.push(`${label} stale evidence git_status_short mismatch for current attempt`);
-    }
-    if (attempt && evidence.tracked_diff_hash !== undefined && evidence.tracked_diff_hash !== attempt.tracked_diff_hash) {
-        failures.push(`${label} stale evidence tracked_diff_hash mismatch for current attempt`);
-    }
-    if (attempt && evidence.relevant_untracked_hash !== undefined && evidence.relevant_untracked_hash !== attempt.relevant_untracked_hash) {
-        failures.push(`${label} stale evidence relevant_untracked_hash mismatch for current attempt`);
-    }
-    if (attempt && evidence.worktree_fingerprint && evidence.worktree_fingerprint !== attempt.worktree_fingerprint) {
-        failures.push(`${label} stale evidence worktree_fingerprint mismatch for current attempt`);
-    }
-    if (attempt && (attempt.git_status_short || attempt.relevant_untracked_hash !== "none") && evidence.covers_dirty_worktree !== true) {
-        failures.push(`${label} dirty worktree evidence must set covers_dirty_worktree=true for current attempt`);
-    }
-    if (attempt && evidence.generated_at && Date.parse(evidence.generated_at) < Date.parse(attempt.started_at)) {
-        failures.push(`${label} stale evidence generated_at predates current attempt`);
-    }
-    if (attempt && evidence.artifact_mtime && Date.parse(evidence.artifact_mtime) < Date.parse(attempt.started_at)) {
-        failures.push(`${label} stale evidence artifact_mtime predates current attempt`);
-    }
-    const commandRun = state.command_runs?.find((item) => item.command_run_id === evidence.command_run_id);
-    if (!commandRun) {
-        failures.push(`${label} missing command run ${evidence.command_run_id || "(missing)"}`);
-    }
-    else {
-        if (commandRun.task_attempt_id !== state.current_attempt_id) {
-            failures.push(`${label} command run ${commandRun.command_run_id} is from old attempt ${commandRun.task_attempt_id}`);
-        }
-        if (commandRun.exit_code !== 0) {
-            failures.push(`${label} command run ${commandRun.command_run_id} exit_code=${commandRun.exit_code}; expected 0`);
-        }
-        if (!commandRun.completed_at) {
-            failures.push(`${label} command run ${commandRun.command_run_id} missing completed_at`);
-        }
-        if (commandRun.command_spec_id !== evidence.command_spec_id) {
-            failures.push(`${label} command_spec_id mismatch between evidence and command run`);
-        }
-    }
-    const commandSpec = state.required_command_specs?.find((item) => item.command_spec_id === evidence.command_spec_id);
-    if (!commandSpec) {
-        failures.push(`${label} missing required command spec ${evidence.command_spec_id || "(missing)"}`);
-    }
-    else if (commandSpec.ac_id !== proofLayerAcId(layerId) || !commandSpec.proof_layers.map(normalizeProofLayerName).includes(proofLayerName(layerId))) {
-        failures.push(`${label} command spec does not cover ${layerId}`);
-    }
-    const ac = state.graph.acceptance_criteria?.[proofLayerAcId(layerId)];
-    const targetAcIds = evidence.target_ac_ids ?? evidence.assertion_result?.target_ac_ids ?? [];
-    if (!targetAcIds.includes(proofLayerAcId(layerId))) {
-        failures.push(`${label} target_ac_ids ${targetAcIds.join(", ") || "(none)"} do not include ${proofLayerAcId(layerId)}`);
-    }
-    const expectedPiIds = ac?.related_plan_items ?? [];
-    const targetPiIds = evidence.target_pi_ids ?? evidence.assertion_result?.target_pi_ids ?? [];
-    for (const piId of expectedPiIds) {
-        if (!targetPiIds.includes(piId)) {
-            failures.push(`${label} target_pi_ids ${targetPiIds.join(", ") || "(none)"} do not include related plan item ${piId}`);
-        }
-    }
-    const targetLayers = (evidence.target_proof_layers ?? evidence.assertion_result?.target_proof_layers ?? []).map(normalizeLayerId);
-    if (!targetLayers.includes(normalizeLayerId(layerId)) && !targetLayers.includes(proofLayerName(layerId))) {
-        failures.push(`${label} target_proof_layers ${targetLayers.join(", ") || "(none)"} do not include ${layerId}`);
-    }
-    if (evidence.assertion_result?.schema_version !== "assertion-result-v2") {
-        failures.push(`${label} assertion_result.schema_version must be assertion-result-v2 for current-attempt machine completion`);
-    }
-    return failures;
-}
-export async function evaluateCurrentAttemptArtifact(workdir, evidence, layerId) {
-    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
-    return validateArtifact(workdir, evidence, label);
-}
-async function validateArtifact(workdir, evidence, label) {
-    const failures = [];
-    if (!evidence.artifact_path) {
-        failures.push(`${label} EvidenceRecordV2 missing artifact_path`);
-        return failures;
-    }
-    const artifact = await resolveArtifactPath(workdir, evidence.artifact_path);
-    if (!artifact) {
-        failures.push(`${label} artifact_path does not exist: ${evidence.artifact_path}`);
-        return failures;
-    }
-    if (evidence.artifact_sha256) {
-        const actual = createHash("sha256").update(await readText(artifact)).digest("hex");
-        if (actual !== evidence.artifact_sha256) {
-            failures.push(`${label} stale evidence artifact_sha256 mismatch for ${evidence.artifact_path}`);
-        }
-    }
-    return failures;
-}
-async function resolveArtifactPath(workdir, artifactPath) {
-    const candidates = path.isAbsolute(artifactPath) ? [artifactPath] : [path.join(workdir, artifactPath), path.join(projectRootFromWorkdir(workdir), artifactPath)];
-    for (const candidate of candidates) {
-        if (await pathExists(candidate)) {
-            return candidate;
-        }
-    }
-    return undefined;
-}
-function proofLayerName(layerId) {
-    const raw = layerId.includes(".") ? layerId.slice(layerId.lastIndexOf(".") + 1) : layerId;
-    return normalizeProofLayerName(raw);
-}
-function proofLayerAcId(layerId) {
-    return layerId.includes(".") ? layerId.slice(0, layerId.lastIndexOf(".")) : "";
-}
-function normalizeLayerId(layerId) {
-    if (!layerId.includes(".")) {
-        return normalizeProofLayerName(layerId);
-    }
-    const acId = proofLayerAcId(layerId);
-    return `${acId}.${proofLayerName(layerId)}`;
-}
-function projectRootFromWorkdir(workdir) {
-    const normalized = workdir.replace(/\\/g, "/");
-    const marker = "/tmp/ty-context/plan-acceptance/";
-    const index = normalized.lastIndexOf(marker);
-    if (index < 0) {
-        return workdir;
-    }
-    return normalized.slice(0, index);
-}

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

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

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

@@ -1,96 +0,0 @@
-import { computeScopeConflicts } from "./superpowers-task-compile.js";
-import { ACCEPTANCE_SCOPES, isSelectedScopeFitSlice, PLAN_DELIVERY_SCOPES, PRODUCT_DELIVERY_SCOPES, SCOPE_FIT_DECISIONS } from "./superpowers-task-fields.js";
-import { isRecord } from "./superpowers-task-state-schema.js";
-export function validateDeliveryContract(state, errors) {
-    const product = state.delivery?.product_architecture_scope;
-    if (!isRecord(product)) {
-        errors.push("Product / Architecture Source delivery scope is missing");
-    }
-    else {
-        requireEnum(errors, "Product / Architecture Source delivery_scope", product.delivery_scope, PRODUCT_DELIVERY_SCOPES);
-        requireBoolean(errors, "Product / Architecture Source full_population_required", product.full_population_required);
-        requireArray(errors, "Product / Architecture Source representative_samples_validate", product.representative_samples_validate);
-        requireArray(errors, "Product / Architecture Source representative_samples_do_not_validate", product.representative_samples_do_not_validate);
-        requireArray(errors, "Product / Architecture Source out_of_scope_backlog", product.out_of_scope_backlog);
-        requireEnum(errors, "Product / Architecture Source scope_fit_decision", product.scope_fit_decision, SCOPE_FIT_DECISIONS);
-        requireText(errors, "Product / Architecture Source selected_scope_fit_slice", product.selected_scope_fit_slice);
-        if (typeof product.selected_scope_fit_slice === "string" && product.selected_scope_fit_slice && !isSelectedScopeFitSlice(product.selected_scope_fit_slice)) {
-            errors.push(`Product / Architecture Source selected_scope_fit_slice must be none or SFC-###: ${product.selected_scope_fit_slice}`);
-        }
-        requireText(errors, "Product / Architecture Source owner_boundary", product.owner_boundary);
-        requireText(errors, "Product / Architecture Source primary_capability_path", product.primary_capability_path);
-        requireArray(errors, "Product / Architecture Source non_completing_outcomes", product.non_completing_outcomes);
-        requireText(errors, "Product / Architecture Source assertion_policy", product.assertion_policy);
-        requireText(errors, "Product / Architecture Source source_authority", product.source_authority);
-        requireText(errors, "Product / Architecture Source product_goal", product.product_goal);
-    }
-    for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
-        requireEnum(errors, `${planId} delivery_scope`, item.delivery_scope, PLAN_DELIVERY_SCOPES);
-        requireText(errors, `${planId} capability_target`, item.capability_target);
-        requireArray(errors, `${planId} representative_samples`, item.representative_samples);
-        requireText(errors, `${planId} full_population_boundary`, item.full_population_boundary);
-        requireArray(errors, `${planId} non_required_population`, item.non_required_population);
-        requireText(errors, `${planId} owner_boundary`, item.owner_boundary);
-        requireText(errors, `${planId} primary_capability_path`, item.primary_capability_path);
-        requireText(errors, `${planId} trigger_contract`, item.trigger_contract);
-        requireText(errors, `${planId} state_transition_contract`, item.state_transition_contract);
-        requireText(errors, `${planId} observable_result_contract`, item.observable_result_contract);
-        requireText(errors, `${planId} assertion_support`, item.assertion_support);
-        requireArray(errors, `${planId} required_assertion_commands`, item.required_assertion_commands);
-        requireArray(errors, `${planId} invalid_implementation_shortcuts`, item.invalid_implementation_shortcuts);
-        requireArray(errors, `${planId} implementation_paths`, item.implementation_paths);
-    }
-    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
-        requireEnum(errors, `${acId} acceptance_scope`, ac.acceptance_scope, ACCEPTANCE_SCOPES);
-        requireArray(errors, `${acId} ac_validates`, ac.ac_validates);
-        requireArray(errors, `${acId} ac_does_not_validate`, ac.ac_does_not_validate);
-        requireText(errors, `${acId} sample_boundary`, ac.sample_boundary);
-        requireBoolean(errors, `${acId} full_population_required`, ac.full_population_required);
-        requireArray(errors, `${acId} related_plan_items`, ac.related_plan_items);
-        requireArray(errors, `${acId} required_proof_layers`, ac.required_proof_layers);
-        requireText(errors, `${acId} assertion_command`, ac.assertion_command);
-        requireArray(errors, `${acId} assertion_artifacts`, ac.assertion_artifacts);
-        requireArray(errors, `${acId} positive_assertions`, ac.positive_assertions);
-        requireArray(errors, `${acId} negative_assertions`, ac.negative_assertions);
-        requireBoolean(errors, `${acId} machine_blocking`, ac.machine_blocking);
-        requireArray(errors, `${acId} invalid_completion_signals`, ac.invalid_completion_signals);
-        requireBoolean(errors, `${acId} assertion_result_required`, ac.assertion_result_required);
-    }
-}
-export function validateScopeConflicts(state, errors) {
-    const conflicts = [...new Set([...(state.delivery?.scope_conflicts ?? []), ...computeScopeConflicts(state)])].filter(Boolean);
-    for (const conflict of conflicts) {
-        if (/scope_conflict_requires_decision/i.test(conflict)) {
-            errors.push(conflict);
-        }
-    }
-}
-export function fullPopulationRequired(state) {
-    return (state.delivery?.product_architecture_scope?.delivery_scope === "full_population_operation" ||
-        state.delivery?.product_architecture_scope?.full_population_required === true ||
-        Object.values(state.graph?.acceptance_criteria ?? {}).some((ac) => ac.acceptance_scope === "full_population_operation" || ac.full_population_required === true));
-}
-function requireEnum(errors, label, value, allowed) {
-    if (typeof value !== "string" || value.trim() === "") {
-        errors.push(`${label} is missing`);
-        return;
-    }
-    if (!allowed.has(value)) {
-        errors.push(`${label} has unknown value: ${value}`);
-    }
-}
-function requireText(errors, label, value) {
-    if (typeof value !== "string" || value.trim() === "") {
-        errors.push(`${label} is missing`);
-    }
-}
-function requireBoolean(errors, label, value) {
-    if (typeof value !== "boolean") {
-        errors.push(`${label} must be true or false`);
-    }
-}
-function requireArray(errors, label, value) {
-    if (!Array.isArray(value)) {
-        errors.push(`${label} is missing`);
-    }
-}

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

@@ -1,14 +0,0 @@
-import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export interface DerivedSuperpowersArtifacts {
-    matrix: Record<string, unknown>;
-    verdict: Record<string, unknown>;
-    files: string[];
-}
-export declare function deriveSuperpowersArtifacts(workdir: string): Promise<DerivedSuperpowersArtifacts>;
-export declare function deriveObjects(state: SuperpowersTaskState): {
-    matrix: Record<string, unknown>;
-    verdict: Record<string, unknown>;
-    progress: Record<string, unknown>;
-};
-export declare function derivedMatchesState(workdir: string, state: SuperpowersTaskState): Promise<string[]>;
-export declare function deriveEvidenceIndex(state: SuperpowersTaskState): Record<string, unknown>;