@multileaf/ai-workflow 0.11.0 → 0.12.0

package/dist/orchestration.js

@@ -1,4 +1,69 @@
+import { execFileSync } from "node:child_process";
+import { join } from "node:path";
+import { realpathSync } from "node:fs";
 export const ORCHESTRATION_AGENTS = ["codex", "claude", "gemini"];
+function git(root, args) {
+    return execFileSync("git", args, { cwd: root, encoding: "utf8" }).trim();
+}
+export function worktreeDirectory(aiw, planId, taskId) {
+    return join(aiw, "worktrees", planId, taskId);
+}
+/**
+ * OPP-010: create one branch-per-task worktree from the current HEAD so
+ * parallel tasks never share a working tree. Branches are named
+ * `aiw/<plan>/<task>` so later human merge is explicit.
+ */
+export function createTaskWorktrees(root, aiw, plan) {
+    const created = new Map();
+    const head = git(root, ["rev-parse", "HEAD"]);
+    for (const task of plan.tasks) {
+        const worktree = worktreeDirectory(aiw, plan.id, task.id);
+        const branch = `aiw/${plan.id}/${task.id}`;
+        git(root, ["worktree", "add", "-b", branch, worktree, head]);
+        created.set(task.id, { worktree, baseCommit: head });
+    }
+    return created;
+}
+/** Final commit recorded from an isolated worktree (evidence for the checkpoint). */
+export function worktreeFinalCommit(worktree) {
+    try {
+        return execFileSync("git", ["-C", worktree, "rev-parse", "HEAD"], {
+            encoding: "utf8",
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Remove isolated worktrees; failed-task worktrees are kept unless forced. */
+export function removeWorktrees(root, paths, options = {}) {
+    for (const path of paths) {
+        try {
+            git(root, ["worktree", "remove", path, options.force ? "--force" : "--force"]);
+        }
+        catch {
+            // A worktree whose branch has unmerged changes refuses plain removal;
+            // callers decide whether to force. Removal failures are non-fatal:
+            // `aiw orchestrate --cleanup` can always retry.
+        }
+    }
+}
+/** List isolated worktrees managed under `<aiw>/worktrees` (for cleanup/doctor). */
+export function listManagedWorktrees(root, aiw) {
+    try {
+        const output = git(root, ["worktree", "list", "--porcelain"]);
+        // git reports fully resolved paths (macOS /tmp is a symlink to /private/tmp)
+        const prefix = realpathSync(join(aiw, "worktrees")) + "/";
+        return output
+            .split("\n")
+            .filter((line) => line.startsWith("worktree "))
+            .map((line) => line.slice("worktree ".length))
+            .filter((path) => path.startsWith(prefix));
+    }
+    catch {
+        return [];
+    }
+}
 export function parseOrchestrationPlan(content) {
     if (/\r(?!\n)/.test(content))
         throw new Error("Orchestration plan contains unsupported characters.");
@@ -59,7 +124,7 @@ export function orchestrationWaves(plan) {
     }
     return waves;
 }
-export async function executeOrchestrationPlan(plan, orchestrator, maxParallel) {
+export async function executeOrchestrationPlan(plan, orchestrator, maxParallel, isolation) {
     validateOrchestrationParallelism(maxParallel);
     const tasks = new Map(plan.tasks.map((task) => [task.id, task]));
     const results = new Map();
@@ -75,11 +140,20 @@ export async function executeOrchestrationPlan(plan, orchestrator, maxParallel)
                     return;
                 }
                 try {
-                    const outcome = await orchestrator.run(task);
+                    const isolated = isolation?.worktrees.get(id);
+                    const outcome = await orchestrator.run(isolated ? { ...task, worktree: isolated.worktree } : task);
+                    const base = isolation?.worktrees.get(id);
                     results.set(id, {
                         id,
                         status: outcome.success ? "passed" : "failed",
                         detail: safeDetail(outcome.detail),
+                        ...(base
+                            ? {
+                                worktree: base.worktree,
+                                baseCommit: base.baseCommit,
+                                finalCommit: worktreeFinalCommit(base.worktree),
+                            }
+                            : {}),
                     });
                 }
                 catch (error) {
@@ -106,7 +180,12 @@ export function serializeOrchestrationPreview(plan) {
 }
 export function serializeOrchestrationResults(plan, results) {
     return `schema: 1\nplan: ${plan.id}\nresults:\n${results
-        .map((result) => `  - id: ${result.id}\n    status: ${result.status}\n    detail: ${JSON.stringify(result.detail)}`)
+        .map((result) => {
+        const isolation = result.worktree
+            ? `\n    worktree: ${JSON.stringify(result.worktree)}\n    baseCommit: ${JSON.stringify(result.baseCommit ?? "")}\n    finalCommit: ${JSON.stringify(result.finalCommit ?? "")}`
+            : "";
+        return `  - id: ${result.id}\n    status: ${result.status}\n    detail: ${JSON.stringify(result.detail)}${isolation}`;
+    })
         .join("\n")}\n`;
 }
 function assertPlanGraph(tasks) {

package/dist/quality-gates.d.ts

@@ -1,2 +1,2 @@
-export type QualityGateStage = "brainstorming" | "specification" | "technical-design" | "plan" | "implementation" | "verification" | "review" | "traceability";
+export type QualityGateStage = "brainstorming" | "specification" | "technical-design" | "plan" | "implementation" | "verification" | "review" | "traceability" | "diagnosis" | "assessment";
 export declare function evaluateQualityGate(stage: QualityGateStage, content: string): string[];

package/dist/quality-gates.js

@@ -30,6 +30,29 @@ export function evaluateQualityGate(stage, content) {
             issues.push("Requirement acceptance criteria must use Given, When, and Then.");
         return issues;
     }
+    if (stage === "diagnosis") {
+        const issues = [];
+        if (!/## Reproduction/.test(content) || !/Command:/.test(content) || !/Observed:/.test(content))
+            issues.push("Diagnosis must include a Reproduction with Command and Observed.");
+        if (!/## Expected/.test(content) || section(content, "Expected") === undefined)
+            issues.push("Diagnosis must state the Expected behavior.");
+        if (!/## Root Cause/.test(content) || section(content, "Root Cause") === undefined)
+            issues.push("Diagnosis must state an evidence-backed Root Cause.");
+        if (!/## Scope/.test(content) || section(content, "Scope") === undefined)
+            issues.push("Diagnosis must state the fix Scope.");
+        return issues;
+    }
+    if (stage === "assessment") {
+        const issues = [];
+        if (!/## Evidence/.test(content) || section(content, "Evidence") === undefined)
+            issues.push("Assessment must include attributed Evidence.");
+        const outcome = /\b(go|clarify|stop)\b/i.exec(section(content, "Outcome") ?? "");
+        if (!outcome)
+            issues.push("Assessment Outcome must be go, clarify, or stop.");
+        if (!/## Rationale/.test(content) || section(content, "Rationale") === undefined)
+            issues.push("Assessment must state the Rationale.");
+        return issues;
+    }
     if (stage === "technical-design")
         return requireSections(content, "Technical Design", [
             "Context",

package/dist/risk-assess.d.ts

@@ -41,6 +41,10 @@ export type RiskAssessment = {
     changedPaths: string[];
 };
 export declare function assessRisk(changes: readonly ChangedFile[], options?: AssessOptions): RiskAssessment;
+/** Working-tree changes for advisory classification (exported for OPP-015 lane suggestion). */
+export declare function collectWorkingTreeChanges(root: string): string[] | undefined;
+/** Deterministic covering-test probe: sibling *.test.* / *.spec.* variants. */
+export declare function hasCoveringTest(root: string, fs: FileSystem): (path: string) => boolean;
 export declare function runRiskAssess(args: string[], root: string, fs: FileSystem): Promise<CommandResult>;
 /**
  * Agent escalation (RDD parity): an agent may raise — never lower — the tier

package/dist/risk-assess.js

@@ -145,8 +145,12 @@ function workingTreeChanges(root) {
 function committedRangeChanges(root, baseRef) {
     return gitLines(root, ["diff", "--name-only", `${baseRef}...HEAD`]);
 }
+/** Working-tree changes for advisory classification (exported for OPP-015 lane suggestion). */
+export function collectWorkingTreeChanges(root) {
+    return workingTreeChanges(root);
+}
 /** Deterministic covering-test probe: sibling *.test.* / *.spec.* variants. */
-function hasCoveringTest(root, fs) {
+export function hasCoveringTest(root, fs) {
     return (path) => {
         const directory = path.slice(0, path.lastIndexOf("/"));
         const base = path.slice(path.lastIndexOf("/") + 1);

package/dist/standards.d.ts

@@ -0,0 +1,34 @@
+/**
+ * OPP-012: Standards discovery — deterministic extraction of codebase
+ * conventions into versioned, evidence-cited standards documents.
+ *
+ * The floor is fully deterministic and offline: conventions are detected from
+ * repository structure and content (test layout, naming, error classes), each
+ * statement carries file:line evidence and an occurrence count, and every
+ * standard starts `inferred` until a human confirms or rejects it. Semantic
+ * retrieval (OPP-008) may later widen coverage; it never bypasses confirmation.
+ */
+import type { FileSystem } from "./types.js";
+export type StandardStatus = "inferred" | "confirmed" | "rejected";
+export type StandardEvidence = {
+    path: string;
+    line: number;
+};
+export type StandardDocument = {
+    topic: string;
+    status: StandardStatus;
+    statements: {
+        convention: string;
+        occurrences: number;
+        evidence: StandardEvidence[];
+    }[];
+};
+export declare function extractStandards(root: string, fs: FileSystem): StandardDocument[];
+export type StandardsIndex = {
+    schema: 1;
+    standards: Record<string, {
+        status: StandardStatus;
+        updatedAt: string;
+    }>;
+};
+export declare function parseStandardsIndex(content: string): StandardsIndex;

package/dist/standards.js

@@ -0,0 +1,159 @@
+/**
+ * OPP-012: Standards discovery — deterministic extraction of codebase
+ * conventions into versioned, evidence-cited standards documents.
+ *
+ * The floor is fully deterministic and offline: conventions are detected from
+ * repository structure and content (test layout, naming, error classes), each
+ * statement carries file:line evidence and an occurrence count, and every
+ * standard starts `inferred` until a human confirms or rejects it. Semantic
+ * retrieval (OPP-008) may later widen coverage; it never bypasses confirmation.
+ */
+import { parse as parseYaml } from "yaml";
+const IGNORED_DIRECTORIES = new Set([
+    "node_modules",
+    ".git",
+    ".aiw",
+    ".agents",
+    ".claude",
+    ".cursor",
+    "dist",
+    "build",
+    "coverage",
+]);
+const SOURCE_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".rb",
+    ".go",
+]);
+function walkFiles(fs, root, directory, limit) {
+    const files = [];
+    const walk = (current, depth) => {
+        if (files.length >= limit || depth > 8)
+            return;
+        const entries = fs.list?.(current) ?? [];
+        for (const entry of entries) {
+            if (files.length >= limit)
+                return;
+            const path = `${current}/${entry}`;
+            const stat = fs.pathType?.(path);
+            if (stat === "directory") {
+                if (!IGNORED_DIRECTORIES.has(entry))
+                    walk(path, depth + 1);
+            }
+            else if (SOURCE_EXTENSIONS.has(entry.slice(entry.lastIndexOf(".")))) {
+                files.push(path);
+            }
+        }
+    };
+    walk(directory, 0);
+    return files;
+}
+function relative(root, path) {
+    return path.startsWith(`${root}/`) ? path.slice(root.length + 1) : path;
+}
+export function extractStandards(root, fs) {
+    const files = walkFiles(fs, root, root, 2000);
+    const relativePaths = files.map((path) => relative(root, path));
+    // Testing convention: co-located *.test.* files vs a dedicated tests tree.
+    const coLocated = relativePaths.filter((path) => /\.(test|spec)\.[a-z]+$/i.test(path));
+    const testsDirectory = relativePaths.filter((path) => /(^|\/)tests?\//i.test(path));
+    const testing = {
+        topic: "testing",
+        status: "inferred",
+        statements: [
+            coLocated.length > 0
+                ? {
+                    convention: `Tests live beside the sources they cover, using *.test.* / *.spec.* file names (${coLocated.length} files).`,
+                    occurrences: coLocated.length,
+                    evidence: coLocated.slice(0, 3).map((path) => ({ path, line: 1 })),
+                }
+                : testsDirectory.length > 0
+                    ? {
+                        convention: `Tests live in a dedicated tests/ tree (${testsDirectory.length} files).`,
+                        occurrences: testsDirectory.length,
+                        evidence: testsDirectory.slice(0, 3).map((path) => ({ path, line: 1 })),
+                    }
+                    : {
+                        convention: "No deterministic testing layout detected.",
+                        occurrences: 0,
+                        evidence: [],
+                    },
+        ],
+    };
+    // Error-handling convention: custom error classes.
+    const errorEvidence = [];
+    let errorCount = 0;
+    for (const path of files) {
+        const content = fs.read(path);
+        const lines = content.split("\n");
+        for (let index = 0; index < lines.length; index += 1) {
+            if (/class\s+\w+Error\b\s+extends\s+(?:\w+Error|Error)\b/.test(lines[index])) {
+                errorCount += 1;
+                if (errorEvidence.length < 3)
+                    errorEvidence.push({ path: relative(root, path), line: index + 1 });
+            }
+        }
+    }
+    const errorHandling = {
+        topic: "error-handling",
+        status: "inferred",
+        statements: [
+            errorCount > 0
+                ? {
+                    convention: `Custom error classes (\`class …Error extends …Error\`) are the error convention (${errorCount} definitions).`,
+                    occurrences: errorCount,
+                    evidence: errorEvidence,
+                }
+                : {
+                    convention: "No custom error classes detected; error convention unknown.",
+                    occurrences: 0,
+                    evidence: [],
+                },
+        ],
+    };
+    // Naming convention: source file casing.
+    const kebab = relativePaths.filter((path) => /(^|\/)[a-z0-9]+(-[a-z0-9]+)*\.[a-z]+$/.test(path) &&
+        !/[A-Z_]/.test(path.split("/").pop() ?? ""));
+    const camel = relativePaths.filter((path) => /[a-z][A-Z]/.test(path.split("/").pop() ?? ""));
+    const naming = {
+        topic: "naming",
+        status: "inferred",
+        statements: [
+            kebab.length >= camel.length
+                ? {
+                    convention: `Source files use kebab-case naming (${kebab.length} files).`,
+                    occurrences: kebab.length,
+                    evidence: kebab.slice(0, 3).map((path) => ({ path, line: 1 })),
+                }
+                : {
+                    convention: `Source files use camelCase naming (${camel.length} files).`,
+                    occurrences: camel.length,
+                    evidence: camel.slice(0, 3).map((path) => ({ path, line: 1 })),
+                },
+        ],
+    };
+    return [testing, errorHandling, naming];
+}
+export function parseStandardsIndex(content) {
+    const value = parseYaml(content);
+    const standards = {};
+    if (value && typeof value === "object") {
+        const entries = value.standards;
+        if (entries && typeof entries === "object")
+            for (const [topic, entry] of Object.entries(entries)) {
+                const status = entry?.status;
+                if (typeof status === "string" && ["inferred", "confirmed", "rejected"].includes(status))
+                    standards[topic] = {
+                        status: status,
+                        updatedAt: new Date().toISOString(),
+                    };
+            }
+    }
+    return { schema: 1, standards };
+}

package/dist/types.d.ts

@@ -1,7 +1,21 @@
 export declare const TARGETS: readonly ["codex", "claude", "cursor", "gemini", "copilot", "universal"];
 export type Target = (typeof TARGETS)[number];
-export declare const HUMAN_APPROVAL_STAGES: readonly ["brainstorming", "specification", "technical-design", "plan", "implementation", "verification", "review", "traceability"];
+export declare const HUMAN_APPROVAL_STAGES: readonly ["brainstorming", "specification", "technical-design", "plan", "implementation", "verification", "review", "traceability", "diagnosis", "assessment"];
 export type HumanApprovalStage = (typeof HUMAN_APPROVAL_STAGES)[number];
+/** OPP-009: processes are independent entry points assembled from shared stage primitives. */
+export declare const PROCESSES: {
+    readonly feature: {
+        readonly stages: readonly ["brainstorming", "specification", "technical-design", "plan", "implementation", "verification", "review", "traceability"];
+    };
+    readonly bugfix: {
+        readonly stages: readonly ["diagnosis", "implementation", "verification", "review"];
+    };
+    readonly "idea-assessment": {
+        readonly stages: readonly ["assessment"];
+    };
+};
+export type WorkflowProcess = keyof typeof PROCESSES;
+export declare const PROCESS_IDS: WorkflowProcess[];
 export type CommandResult = {
     exitCode: number;
     output?: string;

package/dist/types.js

@@ -8,4 +8,28 @@ export const HUMAN_APPROVAL_STAGES = [
     "verification",
     "review",
     "traceability",
+    "diagnosis",
+    "assessment",
 ];
+/** OPP-009: processes are independent entry points assembled from shared stage primitives. */
+export const PROCESSES = {
+    feature: {
+        stages: [
+            "brainstorming",
+            "specification",
+            "technical-design",
+            "plan",
+            "implementation",
+            "verification",
+            "review",
+            "traceability",
+        ],
+    },
+    bugfix: {
+        stages: ["diagnosis", "implementation", "verification", "review"],
+    },
+    "idea-assessment": {
+        stages: ["assessment"],
+    },
+};
+export const PROCESS_IDS = Object.keys(PROCESSES);

package/dist/workflow.d.ts

@@ -2,3 +2,10 @@ import type { CommandResult, FileSystem } from "./types.js";
 import type { WorkflowDependencies } from "./services.js";
 export type WorkflowServices = WorkflowDependencies;
 export declare function runCommand(args: string[], root: string, fs: FileSystem, services?: WorkflowServices): Promise<CommandResult>;
+/**
+ * OPP-014 paired verification: plan tasks declare `Validation: <command> →
+ * <expected>`; reports record `Validation: <command> → <observed>`. The gate
+ * compares the pairs — command match, observed presence, exit-code agreement.
+ * Legacy plans without pair arrows are accepted unchanged (ratchet).
+ */
+export declare function compareVerificationPairs(aiw: string, fs: FileSystem, stage: "implementation" | "verification"): string[];