project-tiny-context-harness 0.2.74 → 0.2.75

package/dist/commands/validate.js

@@ -5,6 +5,12 @@ export async function validate(args) {
     for (const line of report.info) {
         console.log(line);
     }
+    for (const warning of report.warnings ?? []) {
+        console.error(`warning: ${warning}`);
+    }
+    for (const hygiene of report.hygiene ?? []) {
+        console.error(`hygiene: ${hygiene}`);
+    }
     for (const error of report.errors) {
         console.error(`error: ${error}`);
     }

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

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

@@ -0,0 +1,220 @@
+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 +1,2 @@
 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,6 +1,20 @@
 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`);
@@ -12,6 +26,9 @@ export function assertExternalReviewerFields(label, row, evidenceText, errors) {
     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}`);
@@ -19,6 +36,13 @@ export function assertExternalReviewerFields(label, row, evidenceText, errors) {
     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;
@@ -59,6 +83,22 @@ function hasSiblingSubstitutionApproval(row) {
         !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);

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

@@ -107,10 +107,14 @@ export function assertSurfaceConformance(row, label, errors) {
         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`);

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

@@ -1,13 +1,16 @@
 import { pathExists } from "./fs.js";
+import { validateAcceptanceArtifactDiagnostics } from "./plan-acceptance-artifacts.js";
 import { assertExternalReviewerFields } from "./plan-acceptance-evidence.js";
 import { AC_STATUSES, MATRIX_STATUSES, NON_COMPLETE_AC, NON_COMPLETE_MATRIX, assertStructuredNa, assertSurfaceConformance, contextDeltaRequired, findJsonFile, findRows, hasExplicitNoTestScope, isOutOfScope, isSurfaceConformanceRow, overallStatus, readJson, statusOf } from "./plan-acceptance-json.js";
 import { assertReferencedPathsExist, hasRealPageEvidence, isBlankish, isUiFacing, primitiveText, repoRelative, resolveInputDir, valuesAsArray, weakProofHit } from "./plan-validator-common.js";
 export async function validatePlanAcceptance(projectRoot, args = []) {
     const info = [];
+    const warnings = [];
+    const hygiene = [];
     const errors = [];
     const targetDir = await resolveInputDir(projectRoot, args[0], "tmp/ty-context/plan-acceptance");
     if (!(await pathExists(targetDir))) {
-        return { info, errors: [`plan acceptance directory is missing: ${repoRelative(projectRoot, targetDir)}`] };
+        return { info, warnings, hygiene, errors: [`plan acceptance directory is missing: ${repoRelative(projectRoot, targetDir)}`] };
     }
     const matrixFile = await findJsonFile(targetDir, "plan-conformance-matrix");
     const verdictFile = await findJsonFile(targetDir, "final-acceptance-verdict");
@@ -18,12 +21,12 @@ export async function validatePlanAcceptance(projectRoot, args = []) {
         errors.push(`plan acceptance directory is missing *-final-acceptance-verdict.json`);
     }
     if (!matrixFile || !verdictFile) {
-        return { info, errors };
+        return { info, warnings, hygiene, errors };
     }
     const matrix = await readJson(matrixFile, errors);
     const verdict = await readJson(verdictFile, errors);
     if (matrix === undefined || verdict === undefined) {
-        return { info, errors };
+        return { info, warnings, hygiene, errors };
     }
     const matrixRows = findRows(matrix, ["plan_items", "items", "matrix", "entries", "plan_conformance"]);
     const verdictRows = findRows(verdict, ["acceptance_items", "ac_verdicts", "verdicts", "items", "entries", "acs"]);
@@ -31,11 +34,12 @@ export async function validatePlanAcceptance(projectRoot, args = []) {
     await validateVerdictRows(projectRoot, verdictRows, overallStatus(verdict), errors);
     validateCrossReferences(matrixRows, verdictRows, errors);
     validateContextFactReferences(matrix, verdict, matrixRows, verdictRows, errors);
+    await validateAcceptanceArtifactDiagnostics(projectRoot, targetDir, matrixRows, verdictRows, overallStatus(verdict), errors, warnings, hygiene);
     info.push(`checked plan acceptance ${repoRelative(projectRoot, targetDir)} matrix_rows=${matrixRows.length} verdict_rows=${verdictRows.length}`);
     if (errors.length === 0) {
         info.push("Plan acceptance artifact consistency passed");
     }
-    return { info, errors };
+    return { info, warnings, hygiene, errors };
 }
 async function validateMatrixRows(projectRoot, rows, overall, errors) {
     if (rows.length === 0) {

package/dist/lib/validators.d.ts

@@ -1,5 +1,7 @@
 export interface ValidatorReport {
     info: string[];
+    warnings?: string[];
+    hygiene?: string[];
     errors: string[];
 }
 export declare function runValidator(projectRoot: string, gate: string, args?: string[]): Promise<ValidatorReport>;

package/dist/lib/validators.js

@@ -88,6 +88,8 @@ async function validateHarness(projectRoot) {
     const modularityReport = await validateCodeModularity(projectRoot);
     return {
         info: [...contextReport.info, ...modularityReport.info],
+        warnings: [...(contextReport.warnings ?? []), ...(modularityReport.warnings ?? [])],
+        hygiene: [...(contextReport.hygiene ?? []), ...(modularityReport.hygiene ?? [])],
         errors: [...contextReport.errors, ...modularityReport.errors]
     };
 }

package/package.json

@@ -1,69 +1,69 @@
-{
-  "name": "project-tiny-context-harness",
-  "version": "0.2.74",
-  "description": "Minimal project memory and validation harness for AI coding agents.",
-  "license": "MIT",
-  "author": "Seven128",
-  "homepage": "https://github.com/Seven128/project-tiny-context-harness#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Seven128/project-tiny-context-harness.git",
-    "directory": "packages/ty-context"
-  },
-  "bugs": {
-    "url": "https://github.com/Seven128/project-tiny-context-harness/issues"
-  },
-  "keywords": [
-    "ai-agents",
-    "coding-agent",
-    "codex",
-    "claude-code",
-    "cursor",
-    "gemini-cli",
-    "opencode",
-    "agent-context",
-    "context-engineering",
-    "context-management",
-    "agents-md",
-    "project-memory",
-    "agent-memory",
-    "ai-coding",
-    "multi-agent",
-    "llm",
-    "developer-tools",
-    "developer-productivity",
-    "cli",
-    "ty-context",
-    "workflow"
-  ],
-  "type": "module",
-  "bin": {
-    "ty-context": "dist/cli.js"
-  },
-  "files": [
-    "README.md",
-    "dist",
-    "assets",
-    "migrations",
-    "source-mappings.yaml"
-  ],
-  "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test:built": "node --test ../../tests/ty-context/*.test.mjs",
-    "test": "npm run build && node --test ../../tests/ty-context/*.test.mjs",
-    "prepack": "npm run build"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "dependencies": {
-    "@google/design.md": "^0.2.0",
-    "impeccable": "^2.3.2",
-    "yaml": "^2.9.0"
-  },
-  "devDependencies": {
-    "@types/node": "^24.0.0",
-    "typescript": "^5.5.0"
-  }
-}
+{
+  "name": "project-tiny-context-harness",
+  "version": "0.2.75",
+  "description": "Minimal project memory and validation harness for AI coding agents.",
+  "license": "MIT",
+  "author": "Seven128",
+  "homepage": "https://github.com/Seven128/project-tiny-context-harness#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Seven128/project-tiny-context-harness.git",
+    "directory": "packages/ty-context"
+  },
+  "bugs": {
+    "url": "https://github.com/Seven128/project-tiny-context-harness/issues"
+  },
+  "keywords": [
+    "ai-agents",
+    "coding-agent",
+    "codex",
+    "claude-code",
+    "cursor",
+    "gemini-cli",
+    "opencode",
+    "agent-context",
+    "context-engineering",
+    "context-management",
+    "agents-md",
+    "project-memory",
+    "agent-memory",
+    "ai-coding",
+    "multi-agent",
+    "llm",
+    "developer-tools",
+    "developer-productivity",
+    "cli",
+    "ty-context",
+    "workflow"
+  ],
+  "type": "module",
+  "bin": {
+    "ty-context": "dist/cli.js"
+  },
+  "files": [
+    "README.md",
+    "dist",
+    "assets",
+    "migrations",
+    "source-mappings.yaml"
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test:built": "node --test ../../tests/ty-context/*.test.mjs",
+    "test": "npm run build && node --test ../../tests/ty-context/*.test.mjs",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@google/design.md": "^0.2.0",
+    "impeccable": "^2.3.2",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.5.0"
+  }
+}