project-tiny-context-harness 0.2.79 → 0.2.81

package/assets/skills/normal-long-task/SKILL.md

@@ -19,7 +19,7 @@ Convert a given ordinary long-task source into a strict, project-context-aware a
 For this exact plan, what must be true before a future executor can honestly say the task is complete?
 ```
 
-This Skill defines the acceptance standard. It is not an execution framework. For a dedicated prompt that binds the finished checklist to the external Superpowers workflow, directly invoke `/superpowers-long-task` after this Skill has produced or verified the full checklist.
+This Skill defines the acceptance standard. It is not an execution framework. For the composite workflow that binds the finished checklist to Superpowers-backed execution, directly invoke `/composite-long-task-workflow` after this Skill has produced or verified the full checklist.
 
 ## Required Outputs
 
@@ -59,7 +59,7 @@ Use this Skill through explicit invocation:
 /normal-long-task
 ```
 
-Do not rely on broad automatic keyword routing. If the user needs the Superpowers-specific long-task adapter, use `/superpowers-long-task` after this Skill has produced or verified the full checklist.
+Do not rely on broad automatic keyword routing. If the user needs the Superpowers-backed composite long-task workflow, use `/composite-long-task-workflow` after this Skill has produced or verified the full checklist.
 
 ## Use Cases
 
@@ -264,11 +264,11 @@ If only locally unsatisfiable hard blockers remain, pause for the user or extern
 
 ## Autonomous Progress Protocol
 
-The generated target-mode prompt must require maximum safe autonomous progress within current platform, repository, tool and user-authorized permission boundaries. Do not ask the user for work the executor can safely discover, run, inspect or verify itself.
-
-Before treating account, credential or app access as blocked, open the relevant app, browser page, CLI tool or system setting and try existing app sessions, browser cookies, CLI auth, OS credential helpers or other user-authorized local state. If the existing session is absent, expired, permission-denied or requires login/MFA/approval, then pause with the minimal user action list; do not ask the user to send passwords, tokens, cookies or full sensitive fields.
-
-The generated target-mode prompt must inherit current repository/global `AGENTS.md` or agent-instruction permission policy. Authorized `sudo` / `gsudo` / administrator elevation is not a user blocker; the executor must try it before pausing. Pause only if elevation is unavailable, fails, or requires user/system authorization.
+The generated target-mode prompt must require maximum safe autonomous progress within current platform, repository, tool and user-authorized permission boundaries. Do not ask the user for work the executor can safely discover, run, inspect or verify itself.
+
+Before treating account, credential or app access as blocked, open the relevant app, browser page, CLI tool or system setting and try existing app sessions, browser cookies, CLI auth, OS credential helpers or other user-authorized local state. If the existing session is absent, expired, permission-denied or requires login/MFA/approval, then pause with the minimal user action list; do not ask the user to send passwords, tokens, cookies or full sensitive fields.
+
+The generated target-mode prompt must inherit current repository/global `AGENTS.md` or agent-instruction permission policy. Authorized `sudo` / `gsudo` / administrator elevation is not a user blocker; the executor must try it before pausing. Pause only if elevation is unavailable, fails, or requires user/system authorization.
 
 Pause only for locally unsatisfiable hard blockers such as missing accounts, credentials, production access, paid services, legal/security approval, user-only browser sessions or sensitive fields the executor cannot access safely.
 
@@ -445,11 +445,11 @@ Hard requirements:
 - The prompt must identify the full checklist path immediately after the plan path and say it is the complete acceptance standard. Chinese prompts must include this exact sentence: `该文件是完整验收标准，验收以这个为准。完成前必须逐项检查，不满足则继续实现。` English prompts must say the full checklist is the complete acceptance standard, acceptance is judged against it, and every item must be checked before completion.
 - The prompt must identify a local audit path, normally `tmp/ty-context/plan-acceptance/<plan-slug>-local-audit.md`, and require the future executor to read it before resuming, keep it current during execution, and use it only as target-mode acceptance progress state, not Context or proof.
 - If the prompt uses a compact checklist summary, say the full checklist owns details and acceptance authority; the compact summary owns direction, priority and recovery navigation; overlap with the full checklist is allowed; conflicts are resolved in favor of the full checklist.
-- The prompt must require local audit status to start from `unknown / not_run`; only fresh required evidence can mark an AC complete. If any fresh browser / API / runtime / data / test contradiction appears, downgrade the affected AC and overall status and record invalidating evidence.
-- The prompt must state that UI-facing acceptance requires a real page path and matching user-visible state; component / viewmodel / mock / unit test evidence is auxiliary unless the full checklist explicitly says otherwise.
-- The prompt must require maximum safe autonomous progress within current platform, repository, tool and user-authorized permission boundaries. Do not ask the user for work the executor can safely discover, run, inspect or verify itself. If pausing for a locally unsatisfiable hard blocker, provide the minimum user action list: exact page/system/command/owner, field or value location, redaction guidance, values not to send and what the executor will do next.
-- The prompt must say existing local sessions, browser state, CLI auth and OS credential helpers are self-service resources: open the relevant app/page/tool/settings first, use existing local auth if present, and pause only after access is actually absent, expired, permission-denied or requires login/MFA/approval.
-- The prompt must inherit current repository/global `AGENTS.md` or agent-instruction permission policy. Authorized `sudo` / `gsudo` / administrator elevation is not a user blocker; the executor must try it before pausing. Pause only if elevation is unavailable, fails, or requires user/system authorization.
+- The prompt must require local audit status to start from `unknown / not_run`; only fresh required evidence can mark an AC complete. If any fresh browser / API / runtime / data / test contradiction appears, downgrade the affected AC and overall status and record invalidating evidence.
+- The prompt must state that UI-facing acceptance requires a real page path and matching user-visible state; component / viewmodel / mock / unit test evidence is auxiliary unless the full checklist explicitly says otherwise.
+- The prompt must require maximum safe autonomous progress within current platform, repository, tool and user-authorized permission boundaries. Do not ask the user for work the executor can safely discover, run, inspect or verify itself. If pausing for a locally unsatisfiable hard blocker, provide the minimum user action list: exact page/system/command/owner, field or value location, redaction guidance, values not to send and what the executor will do next.
+- The prompt must say existing local sessions, browser state, CLI auth and OS credential helpers are self-service resources: open the relevant app/page/tool/settings first, use existing local auth if present, and pause only after access is actually absent, expired, permission-denied or requires login/MFA/approval.
+- The prompt must inherit current repository/global `AGENTS.md` or agent-instruction permission policy. Authorized `sudo` / `gsudo` / administrator elevation is not a user blocker; the executor must try it before pausing. Pause only if elevation is unavailable, fails, or requires user/system authorization.
 - The prompt must preserve hard-blocker semantics: if only locally unsatisfiable hard blockers remain, pause for the user or external owner instead of marking the goal complete.
 - The prompt must say that local audit is not Context, not product-quality proof, not a global task manager, and not a replacement for project tests, CI, review, human acceptance, Task Contract or workflow-contract `plan.md`.
 - Do not include explanatory preface inside the prompt.

package/dist/commands/composite-long-task.d.ts

@@ -0,0 +1,6 @@
+export declare function compositeLongTask(args: string[]): Promise<void>;
+export declare function runCompositeLongTaskCommand(args: string[], options: {
+    commandName: string;
+    label: string;
+    showHelp: boolean;
+}): Promise<void>;

package/dist/commands/composite-long-task.js

@@ -0,0 +1,103 @@
+import path from "node:path";
+import { applySliceDelta, initializeSuperpowersTask } from "../lib/superpowers-task-state.js";
+import { compileSuperpowersTask } from "../lib/superpowers-task-compile.js";
+import { deriveSuperpowersArtifacts } from "../lib/superpowers-task-derive.js";
+import { runEpochGate, runFinalGate, runSliceGate } from "../lib/superpowers-task-gates.js";
+import { nextSuperpowersSlices } from "../lib/superpowers-task-next-slices.js";
+import { renderCompositeLongTaskGoal } from "../lib/composite-long-task-renderer.js";
+export async function compositeLongTask(args) {
+    await runCompositeLongTaskCommand(args, {
+        commandName: "ty-context composite-long-task",
+        label: "composite long-task",
+        showHelp: true
+    });
+}
+export async function runCompositeLongTaskCommand(args, options) {
+    const subcommand = args[0] ?? "help";
+    const workdirArg = args[1];
+    if (!workdirArg || subcommand === "help") {
+        help(options.commandName, options.showHelp);
+        return;
+    }
+    const workdir = path.resolve(process.cwd(), workdirArg);
+    if (subcommand === "init") {
+        await initializeSuperpowersTask(workdir, { planSlug: path.basename(workdir) });
+        console.log(`initialized ${options.label} state at ${workdirArg}/task-state.json`);
+        return;
+    }
+    if (subcommand === "compile") {
+        const state = await compileSuperpowersTask(workdir);
+        console.log(`compiled ${options.label} graph plan_items=${Object.keys(state.graph.plan_items).length} acs=${Object.keys(state.graph.acceptance_criteria).length}`);
+        return;
+    }
+    if (subcommand === "apply-slice-delta") {
+        const delta = args[2];
+        if (!delta) {
+            throw new Error("apply-slice-delta requires <slice-delta.json>");
+        }
+        await applySliceDelta(workdir, path.resolve(process.cwd(), delta));
+        const result = await deriveSuperpowersArtifacts(workdir);
+        console.log(`applied ${options.label} slice delta and derived files=${result.files.length}`);
+        return;
+    }
+    if (subcommand === "derive") {
+        const result = await deriveSuperpowersArtifacts(workdir);
+        console.log(`derived ${options.label} artifacts files=${result.files.length}`);
+        return;
+    }
+    if (subcommand === "slice-gate") {
+        const sliceId = optionValue(args, "--slice") ?? "";
+        const result = await runSliceGate(workdir, sliceId);
+        console.log(result.passed ? `slice gate passed ${sliceId}` : `slice gate blocked ${result.messages.join("; ")}`);
+        if (!result.passed) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (subcommand === "epoch-gate") {
+        const epochId = optionValue(args, "--epoch") ?? "";
+        const result = await runEpochGate(workdir, epochId);
+        console.log(result.passed ? `epoch gate passed ${epochId}` : `epoch gate blocked ${result.messages.join("; ")}`);
+        return;
+    }
+    if (subcommand === "final-gate") {
+        const result = await runFinalGate(workdir);
+        console.log(`final gate product_goal_complete=${result.product_goal_complete}`);
+        if (!result.product_goal_complete) {
+            process.exitCode = 1;
+            for (const error of result.errors) {
+                console.error(`error: ${error}`);
+            }
+        }
+        return;
+    }
+    if (subcommand === "next-slices") {
+        const limit = Number.parseInt(optionValue(args, "--limit") ?? "5", 10);
+        const slices = await nextSuperpowersSlices(workdir, Number.isFinite(limit) ? limit : 5);
+        console.log(`Next ${Math.min(Number.isFinite(limit) ? limit : 5, 5)} high-value clusters:`);
+        console.log(slices.join("\n"));
+        return;
+    }
+    if (subcommand === "render-goal") {
+        const result = await renderCompositeLongTaskGoal(workdir);
+        console.log(`rendered ${options.label} goal artifacts: ${path.basename(result.goalObjectivePath)} ${path.basename(result.protocolPath)} ${path.basename(result.executionBindingPath)} length=${result.goalObjectiveLength}`);
+        return;
+    }
+    help(options.commandName, options.showHelp);
+}
+function help(commandName, showRenderGoal) {
+    const renderGoal = showRenderGoal ? "\n  render-goal <workdir>                  Render workflow-protocol.md, execution-binding.md and goal-objective.txt" : "";
+    console.log(`${commandName} commands:
+  init <workdir>                         Initialize task-state.json and events.ndjson
+  compile <workdir>                      Compile sources into task graph
+  apply-slice-delta <workdir> <delta>    Apply structured slice delta, evidence and derived views
+  derive <workdir>                       Generate derived/** views
+  slice-gate <workdir> --slice <id>      Validate one slice has real progress
+  epoch-gate <workdir> --epoch <id>      Refresh shared epoch evidence views
+  final-gate <workdir>                   Compute product_goal_complete
+  next-slices <workdir> --limit 5        Recommend next proof clusters${renderGoal}`);
+}
+function optionValue(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}

package/dist/commands/index.js

@@ -1,4 +1,5 @@
 import { checkModularity } from "./check-modularity.js";
+import { compositeLongTask } from "./composite-long-task.js";
 import { doctor } from "./doctor.js";
 import { exportContext } from "./export-context.js";
 import { init } from "./init.js";
@@ -22,6 +23,7 @@ export const commands = {
     "validate-plan-contract": (args) => validate(["validate-plan-contract", ...args]),
     "validate-plan-acceptance": (args) => validate(["validate-plan-acceptance", ...args]),
     "validate-superpowers-state": (args) => validate(["validate-superpowers-state", ...args]),
+    "composite-long-task": compositeLongTask,
     superpowers,
     package: packageSource
 };
@@ -47,8 +49,8 @@ export function help() {
   validate-plan-acceptance <dir>
                        Validate plan-conformance matrix and final verdict consistency
   validate-superpowers-state <dir>
-                       Validate canonical Superpowers task-state.json
-  superpowers <subcommand>
-                       Manage explicit Superpowers long-task state workdirs
+                       Validate canonical Superpowers-backed task-state.json
+  composite-long-task <subcommand>
+                       Manage explicit composite long-task workflow workdirs
   package <subcommand> Maintain package canonical source`);
 }

package/dist/commands/superpowers.js

@@ -1,89 +1,8 @@
-import path from "node:path";
-import { applySliceDelta, initializeSuperpowersTask } from "../lib/superpowers-task-state.js";
-import { compileSuperpowersTask } from "../lib/superpowers-task-compile.js";
-import { deriveSuperpowersArtifacts } from "../lib/superpowers-task-derive.js";
-import { runEpochGate, runFinalGate, runSliceGate } from "../lib/superpowers-task-gates.js";
-import { nextSuperpowersSlices } from "../lib/superpowers-task-next-slices.js";
+import { runCompositeLongTaskCommand } from "./composite-long-task.js";
 export async function superpowers(args) {
-    const subcommand = args[0] ?? "help";
-    const workdirArg = args[1];
-    if (!workdirArg || subcommand === "help") {
-        help();
-        return;
-    }
-    const workdir = path.resolve(process.cwd(), workdirArg);
-    if (subcommand === "init") {
-        await initializeSuperpowersTask(workdir, { planSlug: path.basename(workdir) });
-        console.log(`initialized superpowers task state at ${workdirArg}/task-state.json`);
-        return;
-    }
-    if (subcommand === "compile") {
-        const state = await compileSuperpowersTask(workdir);
-        console.log(`compiled superpowers task graph plan_items=${Object.keys(state.graph.plan_items).length} acs=${Object.keys(state.graph.acceptance_criteria).length}`);
-        return;
-    }
-    if (subcommand === "apply-slice-delta") {
-        const delta = args[2];
-        if (!delta) {
-            throw new Error("apply-slice-delta requires <slice-delta.json>");
-        }
-        await applySliceDelta(workdir, path.resolve(process.cwd(), delta));
-        const result = await deriveSuperpowersArtifacts(workdir);
-        console.log(`applied superpowers slice delta and derived files=${result.files.length}`);
-        return;
-    }
-    if (subcommand === "derive") {
-        const result = await deriveSuperpowersArtifacts(workdir);
-        console.log(`derived superpowers artifacts files=${result.files.length}`);
-        return;
-    }
-    if (subcommand === "slice-gate") {
-        const sliceId = optionValue(args, "--slice") ?? "";
-        const result = await runSliceGate(workdir, sliceId);
-        console.log(result.passed ? `slice gate passed ${sliceId}` : `slice gate blocked ${result.messages.join("; ")}`);
-        if (!result.passed) {
-            process.exitCode = 1;
-        }
-        return;
-    }
-    if (subcommand === "epoch-gate") {
-        const epochId = optionValue(args, "--epoch") ?? "";
-        const result = await runEpochGate(workdir, epochId);
-        console.log(result.passed ? `epoch gate passed ${epochId}` : `epoch gate blocked ${result.messages.join("; ")}`);
-        return;
-    }
-    if (subcommand === "final-gate") {
-        const result = await runFinalGate(workdir);
-        console.log(`final gate product_goal_complete=${result.product_goal_complete}`);
-        if (!result.product_goal_complete) {
-            process.exitCode = 1;
-            for (const error of result.errors) {
-                console.error(`error: ${error}`);
-            }
-        }
-        return;
-    }
-    if (subcommand === "next-slices") {
-        const limit = Number.parseInt(optionValue(args, "--limit") ?? "5", 10);
-        const slices = await nextSuperpowersSlices(workdir, Number.isFinite(limit) ? limit : 5);
-        console.log(`Next ${Math.min(Number.isFinite(limit) ? limit : 5, 5)} high-value clusters:`);
-        console.log(slices.join("\n"));
-        return;
-    }
-    help();
-}
-function help() {
-    console.log(`ty-context superpowers commands:
-  init <workdir>                         Initialize task-state.json and events.ndjson
-  compile <workdir>                      Compile sources into task graph
-  apply-slice-delta <workdir> <delta>    Apply structured slice delta, evidence and derived views
-  derive <workdir>                       Generate derived/** views
-  slice-gate <workdir> --slice <id>      Validate one slice has real progress
-  epoch-gate <workdir> --epoch <id>      Refresh shared epoch evidence views
-  final-gate <workdir>                   Compute product_goal_complete
-  next-slices <workdir> --limit 5        Recommend next proof clusters`);
-}
-function optionValue(args, name) {
-    const index = args.indexOf(name);
-    return index >= 0 ? args[index + 1] : undefined;
+    await runCompositeLongTaskCommand(args, {
+        commandName: "ty-context superpowers",
+        label: "superpowers task",
+        showHelp: false
+    });
 }

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

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

@@ -0,0 +1,109 @@
+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/superpowers-task-assertion-normalizers.d.ts

@@ -0,0 +1,3 @@
+import { type AssertionResult, type NegativeEvidenceScan } from "./superpowers-task-state-schema.js";
+export declare function normalizeAssertionResult(value: unknown): AssertionResult | undefined;
+export declare function normalizeNegativeEvidenceScan(value: unknown): NegativeEvidenceScan | undefined;

package/dist/lib/superpowers-task-assertion-normalizers.js

@@ -0,0 +1,67 @@
+import { isRecord } from "./superpowers-task-state-schema.js";
+export function normalizeAssertionResult(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        schema_version: String(value.schema_version ?? ""),
+        status: String(value.status ?? ""),
+        runner: String(value.runner ?? ""),
+        exit_code: numberValue(value.exit_code),
+        target_ac_ids: stringArray(value.target_ac_ids),
+        target_proof_layers: stringArray(value.target_proof_layers),
+        owner_surface: value.owner_surface === undefined ? undefined : String(value.owner_surface),
+        route: value.route === undefined ? undefined : String(value.route),
+        action: value.action === undefined ? undefined : String(value.action),
+        positive_assertions: checkArray(value.positive_assertions),
+        negative_assertions: checkArray(value.negative_assertions),
+        artifacts: stringArray(value.artifacts)
+    };
+}
+export function normalizeNegativeEvidenceScan(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        schema_version: String(value.schema_version ?? ""),
+        status: String(value.status ?? ""),
+        target_ac_ids: stringArray(value.target_ac_ids),
+        owner_surface: value.owner_surface === undefined ? undefined : String(value.owner_surface),
+        route: value.route === undefined ? undefined : String(value.route),
+        forbidden_findings: findingArray(value.forbidden_findings),
+        required_findings: checkArray(value.required_findings),
+        artifacts: stringArray(value.artifacts)
+    };
+}
+function checkArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord).map((item) => ({
+        id: String(item.id ?? ""),
+        status: String(item.status ?? ""),
+        actual: item.actual === undefined ? undefined : String(item.actual),
+        expected: item.expected === undefined ? undefined : String(item.expected),
+        forbidden_text: item.forbidden_text === undefined ? undefined : String(item.forbidden_text)
+    }));
+}
+function findingArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord).map((item) => ({
+        id: String(item.id ?? ""),
+        status: String(item.status ?? ""),
+        forbidden_text: item.forbidden_text === undefined ? undefined : String(item.forbidden_text),
+        actual: item.actual === undefined ? undefined : String(item.actual)
+    }));
+}
+function stringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((item) => String(item)).filter(Boolean);
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : Number.NaN;
+}

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

@@ -0,0 +1,20 @@
+import { type SuperpowersEvidenceRecord, type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export { normalizeAssertionResult, normalizeNegativeEvidenceScan } from "./superpowers-task-assertion-normalizers.js";
+export type AssertionStatus = "passed" | "failed" | "missing" | "stale" | "not_applicable";
+export interface ProofLayerAssertionEvaluation {
+    assertion_status: AssertionStatus;
+    blocking_assertion_failures: string[];
+    negative_evidence_findings: string[];
+}
+export declare const MACHINE_VERIFIABLE_PROOF_LAYERS: Set<string>;
+export declare const UI_BROWSER_ASSERTION_TYPES: Set<string>;
+export declare function proofLayerName(layerId: string): string;
+export declare function proofLayerAcId(layerId: string): string;
+export declare function isMachineVerifiableLayer(layerId: string): boolean;
+export declare function isUiBrowserLayer(layerId: string): boolean;
+export declare function evaluateAcEvidence(state: SuperpowersTaskState, acId: string): ProofLayerAssertionEvaluation;
+export declare function evaluateProofLayer(state: SuperpowersTaskState, layerId: string): ProofLayerAssertionEvaluation;
+export declare function evaluateProofLayerAssertions(state: SuperpowersTaskState, layerId: string): ProofLayerAssertionEvaluation;
+export declare function assertionFailuresForState(state: SuperpowersTaskState): string[];
+export declare function evaluateAssertionEvidence(evidence: SuperpowersEvidenceRecord, layerId: string): string[];
+export declare function evaluateNegativeEvidence(evidence: SuperpowersEvidenceRecord, layerId: string): string[];