project-tiny-context-harness 0.2.85 → 0.6.1

package/dist/commands/superpowers.d.ts

@@ -1 +0,0 @@
-export declare function superpowers(args: string[]): Promise<void>;

package/dist/commands/superpowers.js

@@ -1,8 +0,0 @@
-import { runCompositeLongTaskCommand } from "./composite-long-task.js";
-export async function superpowers(args) {
-    await runCompositeLongTaskCommand(args, {
-        commandName: "ty-context superpowers",
-        label: "superpowers task",
-        showHelp: false
-    });
-}

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

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

@@ -1,109 +0,0 @@
-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 = await renderExecutionBinding(resolvedWorkdir, protocolSha256);
-    const executionBindingPath = path.join(resolvedWorkdir, "execution-binding.md");
-    await writeTextIfChanged(executionBindingPath, executionBinding);
-    const goalObjective = await 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");
-    }
-}
-async function renderExecutionBinding(workdir, protocolSha256) {
-    return renderTemplateAsset(["skills", "composite-long-task-workflow", "assets", "execution-binding.template.md"], {
-        workdir: path.normalize(workdir),
-        protocol_sha256: protocolSha256
-    });
-}
-async function renderGoalObjective(workdir) {
-    return renderTemplateAsset(["skills", "composite-long-task-workflow", "assets", "goal-objective.template.md"], {
-        workdir
-    });
-}
-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`;
-}
-async function renderTemplateAsset(segments, values) {
-    let rendered = normalizeNewlines(await readText(packageAssetPath(...segments)));
-    for (const [key, value] of Object.entries(values)) {
-        rendered = rendered.replaceAll(`{{${key}}}`, value);
-    }
-    return ensureTrailingNewline(rendered);
-}
-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/plan-acceptance-artifacts.d.ts

@@ -1 +0,0 @@
-export declare function validateAcceptanceArtifactDiagnostics(projectRoot: string, targetDir: string, matrixRows: Record<string, unknown>[], verdictRows: Record<string, unknown>[], verdictOverall: string, errors: string[], warnings: string[], hygiene: string[]): Promise<void>;

package/dist/lib/plan-acceptance-artifacts.js

@@ -1,220 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { readText } from "./fs.js";
-import { findSensitiveEvidence } from "./plan-acceptance-evidence.js";
-import { isOutOfScope, statusOf } from "./plan-acceptance-json.js";
-import { isBlankish, primitiveText, repoRelative, valuesAsArray } from "./plan-validator-common.js";
-const MILESTONE_STATUSES = new Set([
-    "not_started",
-    "implemented_no_proof",
-    "proof_partial",
-    "proof_ready",
-    "complete",
-    "blocked",
-    "out_of_scope_NA"
-]);
-const GENERATED_ACTIVE_COUNTS = /<!--\s*generated:active-counts:start\s*-->([\s\S]*?)<!--\s*generated:active-counts:end\s*-->/i;
-export async function validateAcceptanceArtifactDiagnostics(projectRoot, targetDir, matrixRows, verdictRows, verdictOverall, errors, warnings, hygiene) {
-    validateRows(matrixRows, "plan-conformance matrix row", warnings, hygiene);
-    validateRows(verdictRows, "final acceptance verdict row", warnings, hygiene);
-    const manifestEvidenceIds = await validateEvidenceManifest(projectRoot, targetDir, errors, warnings);
-    if (manifestEvidenceIds.size > 0) {
-        validateEvidenceIdReferences(matrixRows, "plan-conformance matrix row", manifestEvidenceIds, errors);
-        validateEvidenceIdReferences(verdictRows, "final acceptance verdict row", manifestEvidenceIds, errors);
-    }
-    await validateFinalVerdictMarkdown(projectRoot, targetDir, verdictRows, verdictOverall, errors, warnings, hygiene);
-}
-function validateRows(rows, labelPrefix, warnings, hygiene) {
-    for (const [index, row] of rows.entries()) {
-        const label = `${labelPrefix} ${index + 1}`;
-        validateMilestones(row, label, warnings);
-        validateStalePartialText(row, label, hygiene);
-    }
-}
-function validateMilestones(row, label, warnings) {
-    const milestones = row.milestones ?? row.proof_layer_milestones ?? row.proofLayerMilestones;
-    if (isBlankish(milestones)) {
-        return;
-    }
-    for (const status of extractMilestoneStatuses(milestones)) {
-        if (!MILESTONE_STATUSES.has(status)) {
-            warnings.push(`${label} has unsupported milestone status: ${status || "<empty>"}`);
-        }
-    }
-}
-function extractMilestoneStatuses(value) {
-    if (Array.isArray(value)) {
-        return value.flatMap(extractMilestoneStatuses);
-    }
-    if (!value || typeof value !== "object") {
-        return valuesAsArray(value).map((item) => item.trim());
-    }
-    const object = value;
-    if (!isBlankish(object.status)) {
-        return [String(object.status).trim()];
-    }
-    return Object.values(object).flatMap(extractMilestoneStatuses);
-}
-function validateStalePartialText(row, label, hygiene) {
-    const status = statusOf(row);
-    if (status === "complete" || status === "out_of_scope_NA") {
-        return;
-    }
-    const text = primitiveText(row);
-    const hasCompletionClaim = /\b(accepted|complete|final passed|goal achieved|product_goal_complete=true)\b/i.test(text);
-    const hasStaleQualifier = /\b(old|stale|previously|prior|outdated|superseded|no longer current)\b/i.test(text);
-    if (hasCompletionClaim && hasStaleQualifier) {
-        hygiene.push(`${label} has stale or overclaim completion prose while status is ${status || "<empty>"}`);
-    }
-}
-async function validateEvidenceManifest(projectRoot, targetDir, errors, warnings) {
-    const manifestFile = await findFile(targetDir, "evidence-manifest", ".json");
-    const evidenceIds = new Set();
-    if (!manifestFile) {
-        return evidenceIds;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(await readText(manifestFile));
-    }
-    catch (error) {
-        errors.push(`${repoRelative(projectRoot, manifestFile)} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-        return evidenceIds;
-    }
-    const entries = findManifestEntries(parsed);
-    if (entries.length === 0) {
-        warnings.push(`${repoRelative(projectRoot, manifestFile)} has no evidence entries`);
-        return evidenceIds;
-    }
-    for (const [index, entry] of entries.entries()) {
-        const label = `evidence manifest entry ${index + 1}`;
-        const evidenceId = firstString(entry.evidence_id, entry.evidenceId, entry.id);
-        if (evidenceId) {
-            evidenceIds.add(evidenceId);
-        }
-        else {
-            errors.push(`${label} is missing evidence_id`);
-        }
-        warnIfBlank(entry, label, warnings, "slice_id", "sliceId");
-        warnIfBlank(entry, label, warnings, "slice_goal", "sliceGoal");
-        warnIfBlank(entry, label, warnings, "touched_plan_item_ids", "touched_plan_ids", "plan_item_ids");
-        warnIfBlank(entry, label, warnings, "touched_ac_ids", "acceptance_ids", "ac_ids");
-        warnIfBlank(entry, label, warnings, "missing_layer_classes");
-        warnIfBlank(entry, label, warnings, "proves");
-        warnIfBlank(entry, label, warnings, "explicitly_does_not_prove", "does_not_prove");
-        warnIfBlank(entry, label, warnings, "closed_missing_layers", "closed_layers");
-        warnIfBlank(entry, label, warnings, "remaining_missing_layers", "remaining_layers");
-        warnIfBlank(entry, label, warnings, "cleanup_status");
-        warnIfBlank(entry, label, warnings, "redaction_security_status", "security_redaction_status");
-        warnIfBlank(entry, label, warnings, "freshness");
-        const sensitiveEvidence = findSensitiveEvidence(primitiveText(entry));
-        if (sensitiveEvidence) {
-            errors.push(`${label} contains raw secret/token/cookie material: ${sensitiveEvidence}`);
-        }
-        if (entry.safe_to_sync_to_verdict === true && !isBlankish(entry.remaining_missing_layers ?? entry.remaining_layers)) {
-            warnings.push(`${label} is safe_to_sync_to_verdict but still has remaining missing layers`);
-        }
-    }
-    return evidenceIds;
-}
-function findManifestEntries(value) {
-    if (Array.isArray(value)) {
-        return value.filter(isRecord);
-    }
-    if (!isRecord(value)) {
-        return [];
-    }
-    for (const key of ["evidence", "entries", "items", "manifest"]) {
-        const rows = findManifestEntries(value[key]);
-        if (rows.length > 0) {
-            return rows;
-        }
-    }
-    return [];
-}
-function validateEvidenceIdReferences(rows, labelPrefix, evidenceIds, errors) {
-    for (const [index, row] of rows.entries()) {
-        for (const evidenceId of valuesAsArray(row.evidence_id ?? row.evidence_ids ?? row.evidenceId ?? row.evidenceIds)) {
-            if (!evidenceIds.has(evidenceId)) {
-                errors.push(`${labelPrefix} ${index + 1} references unknown evidence_id: ${evidenceId}`);
-            }
-        }
-    }
-}
-async function validateFinalVerdictMarkdown(projectRoot, targetDir, verdictRows, verdictOverall, errors, warnings, hygiene) {
-    const markdownFile = await findFile(targetDir, "final-acceptance-verdict", ".md");
-    if (!markdownFile) {
-        return;
-    }
-    const content = await readText(markdownFile);
-    const match = GENERATED_ACTIVE_COUNTS.exec(content);
-    if (!match) {
-        if (/\b(active[-_ ]?count|complete_count|acceptance_required_count|missing_layer_count)\b/i.test(content)) {
-            hygiene.push(`${repoRelative(projectRoot, markdownFile)} has active-count-like prose outside generated active-count markers`);
-        }
-        return;
-    }
-    const declared = parseCountBlock(match[1]);
-    const actual = activeCounts(verdictRows);
-    for (const [key, expected] of Object.entries(actual)) {
-        const declaredValue = declared[key];
-        if (declaredValue === undefined) {
-            warnings.push(`${repoRelative(projectRoot, markdownFile)} generated active-count block is missing ${key}`);
-            continue;
-        }
-        if (declaredValue !== expected) {
-            const message = `${repoRelative(projectRoot, markdownFile)} generated active-count ${key}=${declaredValue} but current verdict has ${expected}`;
-            if (verdictOverall === "complete") {
-                errors.push(message);
-            }
-            else {
-                warnings.push(message);
-            }
-        }
-    }
-}
-function parseCountBlock(content) {
-    const counts = {};
-    for (const line of content.split(/\r?\n/)) {
-        const match = /^\s*([A-Za-z0-9_-]+)\s*[:=]\s*(\d+)\s*$/.exec(line);
-        if (match) {
-            counts[match[1].replace(/-/g, "_")] = Number(match[2]);
-        }
-    }
-    return counts;
-}
-function activeCounts(rows) {
-    return {
-        complete_count: rows.filter((row) => statusOf(row) === "complete").length,
-        partial_count: rows.filter((row) => statusOf(row) === "partial").length,
-        acceptance_required_count: rows.filter((row) => !isOutOfScope(row)).length,
-        missing_layer_count: rows.reduce((sum, row) => sum + missingLayerCount(row), 0)
-    };
-}
-function missingLayerCount(row) {
-    return valuesAsArray(row.missing_required_layers ?? row.missingRequiredLayers ?? row.missing_proof_layers ?? row.missing_evidence).length;
-}
-async function findFile(targetDir, marker, extension) {
-    const entries = await fs.readdir(targetDir, { withFileTypes: true });
-    return entries
-        .filter((entry) => entry.isFile() && entry.name.endsWith(extension) && entry.name.includes(marker))
-        .map((entry) => path.join(targetDir, entry.name))
-        .sort()[0];
-}
-function warnIfBlank(entry, label, warnings, ...keys) {
-    if (keys.some((key) => !isBlankish(entry[key]))) {
-        return;
-    }
-    warnings.push(`${label} is missing ${keys[0]}`);
-}
-function firstString(...values) {
-    for (const value of values) {
-        if (!isBlankish(value)) {
-            return String(value).trim();
-        }
-    }
-    return undefined;
-}
-function isRecord(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}

package/dist/lib/plan-acceptance-evidence.d.ts

@@ -1,2 +0,0 @@
-export declare function assertExternalReviewerFields(label: string, row: Record<string, unknown>, evidenceText: string, errors: string[]): void;
-export declare function findSensitiveEvidence(text: string): string | undefined;

package/dist/lib/plan-acceptance-evidence.js

@@ -1,108 +0,0 @@
-import { isOutOfScope } from "./plan-acceptance-json.js";
-import { isBlankish, primitiveText, valuesAsArray } from "./plan-validator-common.js";
-const BLOCKING_AUDITOR_STATUSES = new Set(["partial", "blocked", "invalidated"]);
-const SENSITIVE_EVIDENCE_PATTERNS = [
-    {
-        label: "Authorization bearer token",
-        pattern: /\bauthorization\s*:\s*bearer\s+(?!<redacted>|redacted|\[redacted\])[A-Za-z0-9._~+/=-]{8,}/i
-    },
-    {
-        label: "cookie value",
-        pattern: /\bcookie\s*[:=]\s*(?!<redacted>|redacted|\[redacted\])[^;\s]{8,}/i
-    },
-    {
-        label: "secret assignment",
-        pattern: /\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|secret|password)\s*[:=]\s*["']?(?!<redacted>|redacted|\[redacted\])[A-Za-z0-9_./+=-]{8,}/i
-    }
-];
-export function assertExternalReviewerFields(label, row, evidenceText, errors) {
-    if (hasUnresolvedMissingRequiredLayers(row)) {
-        errors.push(`${label} is complete but missing_required_layers is not empty`);
-    }
-    const driftSeverity = String(row.drift_severity ?? row.driftSeverity ?? "").trim().toLowerCase();
-    if (driftSeverity === "material" || driftSeverity === "critical") {
-        errors.push(`${label} is complete but drift_severity is ${driftSeverity}`);
-    }
-    if (siblingSubstitutionUsed(row) && !hasSiblingSubstitutionApproval(row)) {
-        errors.push(`${label} is complete but sibling_substitution_used without approval`);
-    }
-    if (liveProofSubstitutionUsed(row) && !hasLiveProofSubstitutionApproval(row)) {
-        errors.push(`${label} is complete but live_proof_substitution_used without approval`);
-    }
-    const auditorStatus = String(row.auditor_status ?? row.auditorStatus ?? "").trim().toLowerCase();
-    if (BLOCKING_AUDITOR_STATUSES.has(auditorStatus)) {
-        errors.push(`${label} is complete but auditor_status is ${auditorStatus}`);
-    }
-    if (hasOnlySelfCertifyingEvidence(evidenceText)) {
-        errors.push(`${label} is complete but fresh_evidence contains only summary or self-certifying evidence`);
-    }
-    const sensitiveEvidence = findSensitiveEvidence(evidenceText);
-    if (sensitiveEvidence) {
-        errors.push(`${label} is complete but evidence contains raw secret/token/cookie material: ${sensitiveEvidence}`);
-    }
-}
-export function findSensitiveEvidence(text) {
-    return SENSITIVE_EVIDENCE_PATTERNS.find((item) => item.pattern.test(text))?.label;
-}
-function hasUnresolvedMissingRequiredLayers(row) {
-    const value = row.missing_required_layers ?? row.missingRequiredLayers ?? row.missing_proof_layers;
-    if (isBlankish(value)) {
-        return false;
-    }
-    if (Array.isArray(value)) {
-        return value.some((item) => !isBlankish(item) && !isStructuredLayerNa(item));
-    }
-    return !isStructuredLayerNa(value);
-}
-function isStructuredLayerNa(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return false;
-    }
-    const object = value;
-    const text = primitiveText(object);
-    const hasNaStatus = isOutOfScope(object) || /\bout[_ -]?of[_ -]?scope[_ -]?NA\b/i.test(text);
-    const hasSource = !isBlankish(object.scope_source) ||
-        !isBlankish(object.approval_source) ||
-        !isBlankish(object.source_reference) ||
-        !isBlankish(object.sourceReference);
-    return hasNaStatus && hasSource;
-}
-function siblingSubstitutionUsed(row) {
-    const value = row.sibling_substitution_used ?? row.siblingSubstitutionUsed;
-    if (value === true) {
-        return true;
-    }
-    const text = primitiveText(value);
-    if (/\b(false|no|none|not used|not_used)\b/i.test(text)) {
-        return false;
-    }
-    return /\b(true|yes|used|present)\b/i.test(text);
-}
-function hasSiblingSubstitutionApproval(row) {
-    return (!isBlankish(row.sibling_substitution_approval_source) ||
-        !isBlankish(row.substitution_approval_source) ||
-        /\b(approved|explicitly allowed|out[_ -]?of[_ -]?scope[_ -]?NA)\b/i.test(primitiveText([row.sibling_substitution_approved, row.substitution_approval])));
-}
-function liveProofSubstitutionUsed(row) {
-    const value = row.live_proof_substitution_used ?? row.liveProofSubstitutionUsed;
-    if (value === true) {
-        return true;
-    }
-    const text = primitiveText(value);
-    if (/\b(false|no|none|not used|not_used)\b/i.test(text)) {
-        return false;
-    }
-    return /\b(true|yes|used|present|substituted)\b/i.test(text);
-}
-function hasLiveProofSubstitutionApproval(row) {
-    return (!isBlankish(row.live_proof_substitution_approval_source) ||
-        !isBlankish(row.liveProofSubstitutionApprovalSource) ||
-        /\b(approved|explicitly allowed|out[_ -]?of[_ -]?scope[_ -]?NA)\b/i.test(primitiveText([row.live_proof_substitution_approved, row.liveProofSubstitutionApproved])));
-}
-function hasOnlySelfCertifyingEvidence(text) {
-    const entries = valuesAsArray(text);
-    return entries.length > 0 && entries.every(isSelfCertifyingEvidence);
-}
-function isSelfCertifyingEvidence(text) {
-    return /\b(local audit|audit says|plan[- ]conformance(?: matrix)?|matrix row|final[- ]acceptance[- ]verdict|final verdict|verdict row|subagent summary|agent summary|reviewer summary|validator pass|validate-plan-acceptance(?: passed| pass)?|green check|final result card)\b/i.test(text);
-}

package/dist/lib/plan-acceptance-json.d.ts

@@ -1,15 +0,0 @@
-export declare const MATRIX_STATUSES: Set<string>;
-export declare const AC_STATUSES: Set<string>;
-export declare const NON_COMPLETE_MATRIX: Set<string>;
-export declare const NON_COMPLETE_AC: Set<string>;
-export declare function findJsonFile(targetDir: string, marker: string): Promise<string | undefined>;
-export declare function readJson(file: string, errors: string[]): Promise<unknown>;
-export declare function findRows(value: unknown, preferredKeys: string[]): Record<string, unknown>[];
-export declare function overallStatus(value: unknown): string;
-export declare function statusOf(row: Record<string, unknown>): string;
-export declare function isOutOfScope(row: Record<string, unknown>): boolean;
-export declare function contextDeltaRequired(value: unknown): boolean;
-export declare function isSurfaceConformanceRow(row: Record<string, unknown>): boolean;
-export declare function hasExplicitNoTestScope(row: Record<string, unknown>): boolean;
-export declare function assertSurfaceConformance(row: Record<string, unknown>, label: string, errors: string[]): void;
-export declare function assertStructuredNa(row: Record<string, unknown>, label: string, errors: string[]): void;

package/dist/lib/plan-acceptance-json.js

@@ -1,133 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { readText } from "./fs.js";
-import { isBlankish, primitiveText, valuesAsArray } from "./plan-validator-common.js";
-export const MATRIX_STATUSES = new Set([
-    "complete",
-    "partial",
-    "sampled_only",
-    "not_implemented",
-    "blocked",
-    "scope_changed_requires_user_approval",
-    "contradicted_by_current_state",
-    "out_of_scope_NA"
-]);
-export const AC_STATUSES = new Set(["complete", "partial", "blocked", "not_run", "invalidated", "out_of_scope_NA"]);
-export const NON_COMPLETE_MATRIX = new Set([
-    "partial",
-    "sampled_only",
-    "not_implemented",
-    "blocked",
-    "scope_changed_requires_user_approval",
-    "contradicted_by_current_state"
-]);
-export const NON_COMPLETE_AC = new Set(["partial", "blocked", "not_run", "invalidated"]);
-export async function findJsonFile(targetDir, marker) {
-    const entries = await fs.readdir(targetDir, { withFileTypes: true });
-    return entries
-        .filter((entry) => entry.isFile() && entry.name.endsWith(".json") && entry.name.includes(marker))
-        .map((entry) => path.join(targetDir, entry.name))
-        .sort()[0];
-}
-export async function readJson(file, errors) {
-    try {
-        return JSON.parse(await readText(file));
-    }
-    catch (error) {
-        errors.push(`${file} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-        return undefined;
-    }
-}
-export function findRows(value, preferredKeys) {
-    if (Array.isArray(value) && value.every((item) => item && typeof item === "object" && !Array.isArray(item))) {
-        return value;
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return [];
-    }
-    const object = value;
-    for (const key of preferredKeys) {
-        const rows = findRows(object[key], []);
-        if (rows.length > 0) {
-            return rows;
-        }
-    }
-    return Object.values(object).map((item) => findRows(item, [])).sort((a, b) => b.length - a.length)[0] ?? [];
-}
-export function overallStatus(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return "";
-    }
-    const object = value;
-    return String(object.overall_status ?? object.overallStatus ?? object.status ?? "").trim();
-}
-export function statusOf(row) {
-    return String(row.status ?? "").trim();
-}
-export function isOutOfScope(row) {
-    return statusOf(row) === "out_of_scope_NA" || /out[_ -]?of[_ -]?scope|n\/a|not applicable/i.test(primitiveText(row));
-}
-export function contextDeltaRequired(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return false;
-    }
-    const object = value;
-    return [
-        object.context_delta,
-        object.contextDelta,
-        object.product_context_delta,
-        object.productContextDelta,
-        object.technical_context_delta,
-        object.technicalContextDelta
-    ].some((item) => /\brequired\b/i.test(primitiveText(item)));
-}
-export function isSurfaceConformanceRow(row) {
-    return (/\b(product[_ -]?surface|surface|ia|information[_ -]?architecture|architecture[_ -]?migration|ui)\b/i.test(primitiveText(row.conformance_type)) ||
-        !isBlankish(row.owner_surface) ||
-        !isBlankish(row.forbidden_primary_surfaces) ||
-        !isBlankish(row.required_user_paths));
-}
-export function hasExplicitNoTestScope(row) {
-    return /\b(no[- ]?test|no automated test|test out of scope|tests? not required)\b/i.test(primitiveText([row.test_scope, row.no_test_scope, row.tests]));
-}
-export function assertSurfaceConformance(row, label, errors) {
-    if (isBlankish(row.owner_surface)) {
-        errors.push(`${label} is surface/architecture conformance but owner_surface is empty`);
-    }
-    if (isBlankish(row.required_user_paths)) {
-        errors.push(`${label} is surface/architecture conformance but required_user_paths is empty`);
-    }
-    if (isBlankish(row.real_page_evidence)) {
-        errors.push(`${label} is surface/architecture conformance but real_page_evidence is empty`);
-    }
-    if (isBlankish(row.context_fact_refs)) {
-        errors.push(`${label} is surface/architecture conformance but context_fact_refs is empty`);
-    }
-    if (!isBlankish(row.forbidden_primary_surfaces) && isBlankish(row.negative_surface_checks)) {
-        errors.push(`${label} declares forbidden_primary_surfaces but negative_surface_checks is empty`);
-    }
-    const userPathText = primitiveText([row.required_user_paths, row.primary_user_paths]);
-    const evidenceText = primitiveText([row.real_page_evidence, row.user_path_evidence, row.fresh_evidence, row.runtime_evidence, row.artifact_evidence]);
-    for (const forbiddenSurface of valuesAsArray(row.forbidden_primary_surfaces)) {
-        if (userPathText.toLowerCase().includes(forbiddenSurface.toLowerCase())) {
-            errors.push(`${label} routes a required/primary user path through forbidden surface: ${forbiddenSurface}`);
-        }
-        if (evidenceText.toLowerCase().includes(forbiddenSurface.toLowerCase())) {
-            errors.push(`${label} uses wrong owner surface evidence from forbidden surface: ${forbiddenSurface}`);
-        }
-    }
-    if (row.default_visibility_required === true && !mentionsDefaultVisibility(primitiveText(row.real_page_evidence))) {
-        errors.push(`${label} requires default visibility but real_page_evidence does not record default-visible proof`);
-    }
-}
-export function assertStructuredNa(row, label, errors) {
-    if (isBlankish(row.na_reason) && isBlankish(row.out_of_scope_reason)) {
-        errors.push(`${label} is out_of_scope_NA but lacks na_reason or out_of_scope_reason`);
-    }
-    if (isBlankish(row.scope_source) && isBlankish(row.approval_source) && isBlankish(row.source_reference)) {
-        errors.push(`${label} is out_of_scope_NA but lacks scope_source, approval_source or source_reference`);
-    }
-}
-function mentionsDefaultVisibility(value) {
-    return /\b(default[- ]?visible|visible by default|primary entry|first-level|top-level|main entry)\b/i.test(value);
-}

package/dist/lib/plan-acceptance-validator.d.ts

@@ -1,2 +0,0 @@
-import type { ValidatorReport } from "./validators.js";
-export declare function validatePlanAcceptance(projectRoot: string, args?: string[]): Promise<ValidatorReport>;