@kontourai/flow-agents 0.1.1

package/build/src/cli/validate-hook-influence.js

@@ -0,0 +1,152 @@
+import * as fs from "node:fs";
+const validTiers = new Set(["adapter", "design-target", "installed-command", "live-acceptance", "documented-runtime-gap"]);
+const validRuntimes = new Set(["codex", "claude-code", "kiro-cli"]);
+const validHooks = new Set(["workflow-steering", "stop-goal-fit"]);
+const validEvents = new Set(["UserPromptSubmit", "PostToolUse", "Stop"]);
+const requiredCases = {
+    "dev-builder-build-requires-pickup-probe-before-plan": { description: "missing pickup Probe before plan", tier: "design-target", must_include: ["design-probe", "accepted gaps", "provider_state", "conflict_risks"], agent_must_do: ["route decision_gap back to design-probe/pickup Probe"] },
+    "dev-builder-review-before-verify-after-execute": { description: "review-before-verify after execute", tier: "adapter", event: "PostToolUse", must_include: ["Next: review", "then verify", "report only"], agent_must_do: ["review-work for report-only critique before verify-work", "not count critique.json as verification evidence"] },
+    "dev-verify-fail-preserves-trace-before-rework": { description: "verify failure route-back with preserved FAIL evidence", tier: "design-target", must_include: ["If verdict=FAIL: record the FAIL artifact"], agent_must_do: ["write the FAIL artifact before routing back", "route to plan"] },
+    "codex-claude-strict-stop-adapter-contract": { description: "Goal Fit stop adapter behavior", tier: "adapter", hook: "stop-goal-fit", event: "Stop", must_include: ["Goal Fit warning"], agent_must_do: ["treat strict Stop guidance as a blocker"] },
+    "codex-live-context-gap": { description: "Codex documented runtime gap", tier: "documented-runtime-gap", must_include: ["STATE:", "not_verified"], agent_must_do: ["record NOT_VERIFIED for live influence"] },
+    "installed-command-protocol-guidance": { description: "installed-command evidence lane", tier: "installed-command", must_include: ["STATE:", "CRITIQUE:", "CONTEXT MAP:"], agent_must_do: ["treat hook guidance as additional context"] },
+};
+function fail(message) {
+    throw new Error(message);
+}
+function stringList(caseId, payload, key, minimum = 1) {
+    const value = payload[key];
+    if (!Array.isArray(value) || value.length < minimum)
+        fail(`${caseId}: ${key} must contain at least ${minimum} item(s)`);
+    value.forEach((item, index) => {
+        if (typeof item !== "string" || !item.trim())
+            fail(`${caseId}: ${key}[${index}] must be a non-empty string`);
+    });
+    return value;
+}
+function commandTarget(command) {
+    const parts = command.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^['"]|['"]$/g, "")) ?? [];
+    for (let i = 0; i < parts.length; i += 1) {
+        if (parts[i] === "bash" && parts[i + 1])
+            return parts[i + 1];
+        if (parts[i].startsWith("evals/") || parts[i].startsWith("scripts/"))
+            return parts[i];
+    }
+    return undefined;
+}
+function validateEvidenceCommand(caseId, runtimes, evidence) {
+    const command = String(evidence.command);
+    const tier = String(evidence.tier);
+    const target = commandTarget(command);
+    if (!target)
+        fail(`${caseId}: evidence.command must reference a local eval or script path`);
+    if (!fs.existsSync(target))
+        fail(`${caseId}: evidence.command target does not exist: ${target}`);
+    const runtimeSet = new Set(runtimes);
+    if (tier === "live-acceptance") {
+        if (target.includes("evals/acceptance/test_kiro_harness.sh") && (runtimeSet.size !== 1 || !runtimeSet.has("kiro-cli")))
+            fail(`${caseId}: Kiro live acceptance cannot prove runtimes: ${runtimes.sort().join(", ")}`);
+        if (target.includes("evals/acceptance/test_claude_harness.sh") && (runtimeSet.size !== 1 || !runtimeSet.has("claude-code")))
+            fail(`${caseId}: Claude live acceptance cannot prove runtimes: ${runtimes.sort().join(", ")}`);
+        if (target.includes("evals/acceptance/test_codex_harness.sh") && (runtimeSet.size !== 1 || !runtimeSet.has("codex")))
+            fail(`${caseId}: Codex live acceptance cannot prove runtimes: ${runtimes.sort().join(", ")}`);
+        if (!target.includes("evals/acceptance/") && !target.includes("/acceptance/"))
+            fail(`${caseId}: live-acceptance evidence must point to an acceptance harness`);
+    }
+    else if (tier === "installed-command" && !target.includes("evals/integration/test_bundle_install.sh"))
+        fail(`${caseId}: installed-command evidence must point to bundle install integration coverage`);
+    else if (tier === "adapter" && !target.includes("evals/integration/"))
+        fail(`${caseId}: adapter evidence must point to an integration adapter test`);
+    else if (tier === "documented-runtime-gap" && !target.includes("acceptance") && !target.includes("integration"))
+        fail(`${caseId}: documented runtime gaps must still point to an eval boundary`);
+}
+export function main(argv = process.argv.slice(2)) {
+    try {
+        const file = argv[0] ?? "evals/fixtures/hook-influence/cases.json";
+        const data = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (data.schema_version !== "1.0")
+            fail("schema_version must be 1.0");
+        if (!Array.isArray(data.cases) || !data.cases.length)
+            fail("cases must be a non-empty list");
+        const ids = new Set();
+        const casesById = new Map();
+        const byTier = new Set();
+        const runtimeCoverage = new Set();
+        data.cases.forEach((raw, index) => {
+            if (typeof raw !== "object" || raw === null)
+                fail(`cases[${index}] must be an object`);
+            const item = raw;
+            const caseId = typeof item.id === "string" ? item.id : "";
+            if (!caseId.trim())
+                fail(`cases[${index}]: id must be a non-empty string`);
+            if (ids.has(caseId))
+                fail(`${caseId}: duplicate id`);
+            ids.add(caseId);
+            casesById.set(caseId, item);
+            const runtimes = stringList(caseId, item, "runtime_scope");
+            const unknownRuntimes = runtimes.filter((runtime) => !validRuntimes.has(runtime)).sort();
+            if (unknownRuntimes.length)
+                fail(`${caseId}: unknown runtime_scope value(s): ${unknownRuntimes.join(", ")}`);
+            runtimes.forEach((runtime) => runtimeCoverage.add(runtime));
+            if (!validHooks.has(String(item.hook)))
+                fail(`${caseId}: hook must be one of ${[...validHooks].sort().join(", ")}`);
+            if (!validEvents.has(String(item.event)))
+                fail(`${caseId}: event must be one of ${[...validEvents].sort().join(", ")}`);
+            if (typeof item.fixture_state !== "object" || item.fixture_state === null || !Object.keys(item.fixture_state).length)
+                fail(`${caseId}: fixture_state must be a non-empty object`);
+            const guidance = stringList(caseId, item, "guidance_must_include", 2);
+            const actions = stringList(caseId, item, "agent_must_do", 2);
+            if (typeof item.evidence !== "object" || item.evidence === null)
+                fail(`${caseId}: evidence must be an object`);
+            const evidence = item.evidence;
+            const tier = String(evidence.tier);
+            if (!validTiers.has(tier))
+                fail(`${caseId}: evidence.tier must be one of ${[...validTiers].sort().join(", ")}`);
+            byTier.add(tier);
+            ["command", "status"].forEach((key) => { if (typeof evidence[key] !== "string" || !String(evidence[key]).trim())
+                fail(`${caseId}: evidence.${key} must be a non-empty string`); });
+            validateEvidenceCommand(caseId, runtimes, evidence);
+            const req = requiredCases[caseId];
+            if (req) {
+                if (tier !== req.tier)
+                    fail(`${caseId}: ${req.description} must use ${req.tier} evidence tier`);
+                if (req.hook && item.hook !== req.hook)
+                    fail(`${caseId}: ${req.description} must use ${req.hook} hook`);
+                if (req.event && item.event !== req.event)
+                    fail(`${caseId}: ${req.description} must use ${req.event} event`);
+                const guidanceText = guidance.join("\n");
+                const actionText = actions.join("\n");
+                const missingGuidance = (req.must_include ?? []).filter((needle) => !guidanceText.includes(needle));
+                const missingActions = (req.agent_must_do ?? []).filter((needle) => !actionText.includes(needle));
+                if (missingGuidance.length)
+                    fail(`${caseId}: missing required guidance text for ${req.description}: ${missingGuidance.join(", ")}`);
+                if (missingActions.length)
+                    fail(`${caseId}: missing required agent action for ${req.description}: ${missingActions.join(", ")}`);
+            }
+        });
+        const missingRuntimes = [...validRuntimes].filter((runtime) => !runtimeCoverage.has(runtime)).sort();
+        if (missingRuntimes.length)
+            fail(`missing runtime coverage: ${missingRuntimes.join(", ")}`);
+        for (const tier of ["adapter", "installed-command", "live-acceptance", "documented-runtime-gap"])
+            if (!byTier.has(tier))
+                fail(`missing required #62 evidence tier(s): ${tier}`);
+        for (const id of Object.keys(requiredCases))
+            if (!casesById.has(id))
+                fail(`missing required #62 case for ${requiredCases[id].description}: ${id}`);
+        const codexGap = casesById.get("codex-live-context-gap");
+        const codexRuntimes = codexGap.runtime_scope;
+        const codexEvidence = codexGap.evidence;
+        if (codexRuntimes.length !== 1 || codexRuntimes[0] !== "codex")
+            fail("codex-live-context-gap must be scoped only to codex");
+        if (!String(codexEvidence.status).includes("acceptance-covers-routing-not-live-hook-influence"))
+            fail("codex-live-context-gap must not overclaim live model-context influence");
+        console.log(`Hook influence cases valid: ${data.cases.length} case(s).`);
+        return 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`)
+    process.exit(main());

package/build/src/cli/validate-source-tree.js

@@ -0,0 +1,31 @@
+import * as path from "node:path";
+import { parseArgs } from "../lib/args.js";
+import { validateKitRepository } from "../flow-kit/validate.js";
+export function main(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    const kit = args.flags.kit;
+    if (typeof kit === "string") {
+        const errors = validateKitRepository(path.resolve(kit));
+        if (errors.length) {
+            console.log("Flow Kit repository validation failed:");
+            for (const error of errors)
+                console.log(` - ${error}`);
+            return 1;
+        }
+        console.log("Flow Kit repository validation passed");
+        return 0;
+    }
+    const root = path.resolve(".");
+    const builder = path.join(root, "kits", "builder");
+    const errors = validateKitRepository(builder);
+    if (errors.length) {
+        console.log("Source tree validation failed:");
+        for (const error of errors)
+            console.log(` - ${error}`);
+        return 1;
+    }
+    console.log("Source tree validation passed");
+    return 0;
+}
+if (import.meta.url === `file://${process.argv[1]}`)
+    process.exit(main());