@kontourai/flow-agents 2.4.0 → 3.1.0

package/build/src/cli/effective-assignment-provider-settings.d.ts

@@ -0,0 +1 @@
+export declare function main(argv?: string[]): number;

package/build/src/cli/effective-assignment-provider-settings.js

@@ -0,0 +1,125 @@
+import * as child_process from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs, flagString, flagBool } from "../lib/args.js";
+import { readJson } from "../lib/fs.js";
+// Mirrors src/cli/effective-backlog-settings.ts's loadSettings/currentRepo/merge/findProject/
+// effective structure and its ask_user/configured result envelope exactly, pointed at the
+// AssignmentProvider settings schema/example instead of the backlog equivalents (#290 Wave 2
+// Task B). Deliberately NOT extracted into a shared helper with effective-backlog-settings.ts —
+// see the #290 plan artifact's Unresolved Questions #3 for the recorded rationale (duplicating
+// this file's small merge/repo-detection logic is lower-risk than refactoring a file outside
+// this issue's declared scope).
+const PROJECT_SETTINGS_RELATIVE_PATH = path.join("context", "settings", "assignment-provider-settings.json");
+function loadSettings(file) {
+    if (!fs.existsSync(file))
+        return null;
+    const data = readJson(file);
+    if (data.schema_version !== "1.0")
+        throw new Error(`${file}: unsupported schema_version ${String(data.schema_version)}`);
+    return data;
+}
+function repoFromText(text) {
+    const match = text.trim().match(/github\.com[:/]([^/]+)\/([^/.]+)(?:\.git)?$/);
+    return match ? { owner: match[1], name: match[2] } : null;
+}
+function currentRepo(repoPath) {
+    try {
+        const out = child_process.execFileSync("git", ["-C", repoPath, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        const repo = repoFromText(out);
+        if (repo)
+            return repo;
+    }
+    catch { }
+    const packagePath = path.join(repoPath, "package.json");
+    if (fs.existsSync(packagePath)) {
+        const data = readJson(packagePath);
+        const repository = data.repository;
+        const url = typeof repository === "object" && repository !== null ? repository.url : repository;
+        if (typeof url === "string")
+            return repoFromText(url);
+    }
+    return null;
+}
+function merge(base, override) {
+    if (!base && !override)
+        return null;
+    if (!base)
+        return structuredClone(override);
+    if (!override)
+        return structuredClone(base);
+    const out = structuredClone(base);
+    for (const [key, value] of Object.entries(override)) {
+        out[key] = typeof value === "object" && value !== null && typeof out[key] === "object" && out[key] !== null && !Array.isArray(value)
+            ? merge(out[key], value)
+            : structuredClone(value);
+    }
+    return out;
+}
+function findProject(settings, repo) {
+    const projects = settings?.projects;
+    if (!Array.isArray(projects))
+        return null;
+    return projects.find((project) => {
+        const projectRepo = (project.project?.repo ?? {});
+        return projectRepo.owner === repo.owner && projectRepo.name === repo.name;
+    }) ?? null;
+}
+function defaultProjectSettingsPath() {
+    let cursor = path.dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        const candidate = path.join(cursor, PROJECT_SETTINGS_RELATIVE_PATH);
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(cursor);
+        if (parent === cursor)
+            return path.resolve(PROJECT_SETTINGS_RELATIVE_PATH);
+        cursor = parent;
+    }
+}
+function effective(repoPath, projectSettings, globalSettings) {
+    const repo = currentRepo(repoPath);
+    const projectDoc = loadSettings(projectSettings);
+    const globalDoc = loadSettings(globalSettings);
+    if (!repo)
+        return [{ status: "ask_user", reason: "could_not_identify_current_repo", message: "Ask the user which assignment AssignmentProvider to use for this workspace.", resolution: { project_settings_path: projectSettings, global_settings_path: globalSettings } }, 2];
+    const effectiveSettings = merge(merge(merge(globalDoc?.defaults, findProject(globalDoc, repo)), projectDoc?.defaults), findProject(projectDoc, repo));
+    if (!effectiveSettings)
+        return [{ status: "ask_user", reason: "no_assignment_provider_settings", message: "Ask the user which assignment AssignmentProvider to use before claiming work.", current_repo: repo, resolution: { project_settings_path: projectSettings, global_settings_path: globalSettings, checked: ["project", "global"] } }, 2];
+    return [{ status: "configured", current_repo: repo, source: findProject(projectDoc, repo) || projectDoc?.defaults ? "project" : "global", precedence: ["project.projects match", "project.defaults", "global.projects match", "global.defaults"], settings: effectiveSettings }, 0];
+}
+export function main(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    try {
+        const [result, code] = effective(path.resolve(flagString(args.flags, "repo-path", ".") ?? "."), path.resolve(flagString(args.flags, "project-settings", defaultProjectSettingsPath()) ?? ""), path.resolve(flagString(args.flags, "global-settings", path.join(os.homedir(), ".config", "flow-agents", "assignment-provider-settings.json")) ?? ""));
+        if (flagBool(args.flags, "json"))
+            console.log(JSON.stringify(result, null, 2));
+        else
+            console.log(`status: ${String(result.status)}`);
+        return code;
+    }
+    catch (error) {
+        console.error(`error: ${error.message}`);
+        return 1;
+    }
+}
+// Use process.exitCode (not process.exit) to allow stdout to be flushed before exit.
+// Resolve real paths to handle symlinks (e.g. /tmp -> /private/tmp on macOS) so the
+// entry-point guard fires correctly when the module is loaded directly as a script.
+const _selfRealPath = (() => { try {
+    return fs.realpathSync(fileURLToPath(import.meta.url));
+}
+catch {
+    return fileURLToPath(import.meta.url);
+} })();
+const _argv1RealPath = (() => { try {
+    return fs.realpathSync(process.argv[1]);
+}
+catch {
+    return process.argv[1];
+} })();
+if (_selfRealPath === _argv1RealPath) {
+    process.exitCode = main();
+}

package/build/src/cli/validate-workflow-artifacts.js

@@ -467,7 +467,11 @@ function validateSidecarGroup(inputs, markdown, requireSidecars, requireCritique
                 if (bundleValue) {
                     const claims = Array.isArray(bundleValue.claims) ? bundleValue.claims : [];
                     const critiqueClaims = claims.filter((c) => c && c.claimType === "workflow.critique.review");
-                    if (critiqueClaims.some((c) => c.value === "fail" || c.status === "disputed"))
+                    // #282: a historical fail/disputed critique that has been explicitly superseded by a later
+                    // resolving write (metadata.superseded_by) is retained structurally as history and does NOT
+                    // block a top-level pass — only a LIVE (non-superseded) fail/disputed critique blocks.
+                    const isSuperseded = (c) => c && c.metadata && typeof c.metadata === "object" && c.metadata.superseded_by;
+                    if (critiqueClaims.some((c) => (c.value === "fail" || c.status === "disputed") && !isSuperseded(c)))
                         issues.push({ path: trustBundlePath, message: "required critique must pass" });
                 }
             }

package/build/src/cli/workflow-sidecar.d.ts

@@ -145,7 +145,7 @@ type SurfaceModule = {
  * @param critiques  Critique objects (from critique.json .critiques array)
  * @param commandLog Optional parsed command-log.jsonl entries (capture-authoritative fold)
  */
-export declare function buildTrustBundle(slug: string, timestamp: string, checks: AnyObj[], criteria: AnyObj[], critiques: AnyObj[], commandLog?: AnyObj[], flowAgentsDir?: string): Promise<AnyObj | null>;
+export declare function buildTrustBundle(slug: string, timestamp: string, checks: AnyObj[], criteria: AnyObj[], critiques: AnyObj[], commandLog?: AnyObj[], flowAgentsDir?: string, actorKey?: string): Promise<AnyObj | null>;
 /**
  * Fail-open wrapper: builds (via Surface), validates, and writes a trust.bundle.
  * Accepts raw check/criterion/critique inputs directly (ADR 0010 Phase 4a).
@@ -159,7 +159,7 @@ export declare function buildTrustBundle(slug: string, timestamp: string, checks
  * @param criteria   Acceptance criteria objects (same as buildTrustBundle)
  * @param critiques  Critique objects (same as buildTrustBundle)
  */
-export declare function writeTrustBundle(dir: string, slug: string, timestamp: string, checks: AnyObj[], criteria: AnyObj[], critiques: AnyObj[]): Promise<{
+export declare function writeTrustBundle(dir: string, slug: string, timestamp: string, checks: AnyObj[], criteria: AnyObj[], critiques: AnyObj[], actorKey?: string): Promise<{
     written: boolean;
     errors: string[];
 }>;