@multileaf/ai-workflow 0.10.0 → 0.12.0

package/dist/human-approval.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { parseDocument, stringify } from "yaml";
-import { HUMAN_APPROVAL_STAGES } from "./types.js";
+import { HUMAN_APPROVAL_STAGES, PROCESS_IDS, PROCESSES, } from "./types.js";
+export { PROCESS_IDS };
 export const APPROVAL_STAGES = HUMAN_APPROVAL_STAGES;
 /** The lane that currently governs stage commands: escalation moves light → full. */
 export function effectiveLane(session) {
@@ -19,6 +20,8 @@ const STAGE_DEFINITIONS = {
     verification: { optional: false, requiresQualityGate: true },
     review: { optional: false, requiresQualityGate: true },
     traceability: { optional: false, requiresQualityGate: true },
+    diagnosis: { optional: false, requiresQualityGate: true },
+    assessment: { optional: false, requiresQualityGate: true },
 };
 const APPROVAL_STATUSES = ["draft", "pending-human", "approved", "rejected", "skipped", "stale"];
 const QUALITY_GATE_RESULTS = ["not-run", "passed", "failed", "not-applicable"];
@@ -29,7 +32,7 @@ const APPROVAL_RECORD_KEYS = new Set([
     "reason",
     "updatedAt",
 ]);
-const LEDGER_KEYS = new Set(["schema", "workflowId", "stages", "lane", "laneReason"]);
+const LEDGER_KEYS = new Set(["schema", "workflowId", "stages", "lane", "laneReason", "process"]);
 const SESSION_KEYS = new Set([
     "schema",
     "workflowId",
@@ -42,6 +45,7 @@ const SESSION_KEYS = new Set([
     "laneReason",
     "laneEscalatedAt",
     "laneEscalationReason",
+    "abandonedReason",
 ]);
 export function createApprovalLedger(workflowId, options = {}) {
     assertWorkflowId(workflowId);
@@ -54,8 +58,18 @@ export function createApprovalLedger(workflowId, options = {}) {
         ...(options.lane === "light" && options.laneReason
             ? { lane: "light", laneReason: options.laneReason }
             : {}),
+        ...(options.process && options.process !== "feature" ? { process: options.process } : {}),
     };
 }
+/** The ordered stage list for the ledger's process (OPP-009); feature when absent. */
+export function processStages(ledger) {
+    if (!ledger.process || ledger.process === "feature")
+        return [...APPROVAL_STAGES].filter((stage) => stage !== "diagnosis" && stage !== "assessment");
+    return [...PROCESSES[ledger.process].stages];
+}
+export function isWorkflowProcess(value) {
+    return PROCESS_IDS.includes(value);
+}
 export function serializeWorkflowSession(session) {
     validateWorkflowSession(session);
     return stringify(session, { lineWidth: 0 });
@@ -72,8 +86,8 @@ export function parseWorkflowSession(content) {
             throw new Error(`Workflow session has unknown field: ${key}.`);
     if (typeof value.workflowId !== "string")
         throw new Error("Workflow session requires a workflowId.");
-    if (value.status !== "active" && value.status !== "complete")
-        throw new Error("Workflow session status must be active or complete.");
+    if (value.status !== "active" && value.status !== "complete" && value.status !== "abandoned")
+        throw new Error("Workflow session status must be active, complete, or abandoned.");
     if (typeof value.startedAt !== "string" || typeof value.updatedAt !== "string")
         throw new Error("Workflow session requires start and update timestamps.");
     if (value.ticket !== undefined && typeof value.ticket !== "string")
@@ -96,6 +110,9 @@ export function parseWorkflowSession(content) {
     const laneEscalationReason = value.laneEscalationReason;
     if (laneEscalationReason !== undefined && typeof laneEscalationReason !== "string")
         throw new Error("Workflow session lane escalation reason must be a string.");
+    const abandonedReason = value.abandonedReason;
+    if (abandonedReason !== undefined && typeof abandonedReason !== "string")
+        throw new Error("Workflow session abandonment reason must be a string.");
     const session = {
         schema: 1,
         workflowId: value.workflowId,
@@ -108,6 +125,7 @@ export function parseWorkflowSession(content) {
         ...(laneReason === undefined ? {} : { laneReason }),
         ...(laneEscalatedAt === undefined ? {} : { laneEscalatedAt }),
         ...(laneEscalationReason === undefined ? {} : { laneEscalationReason }),
+        ...(abandonedReason === undefined ? {} : { abandonedReason }),
     };
     validateWorkflowSession(session);
     return session;
@@ -119,8 +137,9 @@ export function stageFingerprint(content) {
     return `sha256-${createHash("sha256").update(content).digest("hex")}`;
 }
 export function getUnresolvedPrerequisites(ledger, stage) {
-    const stageIndex = APPROVAL_STAGES.indexOf(stage);
-    return APPROVAL_STAGES.slice(0, stageIndex).filter((prerequisite) => {
+    const stages = processStages(ledger);
+    const stageIndex = stages.indexOf(stage);
+    return stages.slice(0, stageIndex).filter((prerequisite) => {
         const status = ledger.stages[prerequisite]?.status;
         return status !== "approved" && status !== "skipped";
     });
@@ -191,14 +210,23 @@ export function skipOptionalStage(ledger, stage, input) {
 }
 export function invalidateStageAndDescendants(ledger, stage, updatedAt) {
     assertTimestamp(updatedAt);
-    const stageIndex = APPROVAL_STAGES.indexOf(stage);
     const stages = { ...ledger.stages };
-    for (const affected of APPROVAL_STAGES.slice(stageIndex)) {
+    const ordered = processStages(ledger);
+    const stageIndex = ordered.indexOf(stage);
+    for (const affected of ordered.slice(stageIndex)) {
         const record = stages[affected];
         if (record && record.status !== "draft")
             stages[affected] = { ...record, status: "stale", updatedAt };
     }
-    return { schema: 1, workflowId: ledger.workflowId, stages };
+    return {
+        schema: 1,
+        workflowId: ledger.workflowId,
+        stages,
+        ...(ledger.lane === "light" && ledger.laneReason
+            ? { lane: ledger.lane, laneReason: ledger.laneReason }
+            : {}),
+        ...(ledger.process && ledger.process !== "feature" ? { process: ledger.process } : {}),
+    };
 }
 export function serializeApprovalLedger(ledger) {
     validateLedger(ledger);
@@ -210,6 +238,7 @@ export function serializeApprovalLedger(ledger) {
         ...(ledger.lane === "light" && ledger.laneReason
             ? { lane: ledger.lane, laneReason: ledger.laneReason }
             : {}),
+        ...(ledger.process && ledger.process !== "feature" ? { process: ledger.process } : {}),
     }, { lineWidth: 0 });
 }
 export function parseApprovalLedger(content) {
@@ -233,10 +262,14 @@ export function parseApprovalLedger(content) {
             throw new Error(`Approval ledger has unknown workflow stage: ${stageName}.`);
         stages[stageName] = parseStageRecord(stageName, record);
     }
+    const process = value.process === undefined ? undefined : String(value.process);
+    if (process !== undefined && !isWorkflowProcess(process))
+        throw new Error("Approval ledger process must be a known workflow process.");
     const ledger = {
         schema: 1,
         workflowId: value.workflowId,
         stages,
+        ...(process && process !== "feature" ? { process: process } : {}),
         ...(value.lane === "light" && typeof value.laneReason === "string"
             ? { lane: "light", laneReason: value.laneReason }
             : {}),
@@ -266,8 +299,10 @@ function validateWorkflowSession(session) {
     if (session.schema !== 1)
         throw new Error("Workflow session schema must be version 1.");
     assertWorkflowId(session.workflowId);
-    if (session.status !== "active" && session.status !== "complete")
-        throw new Error("Workflow session status must be active or complete.");
+    if (session.status !== "active" &&
+        session.status !== "complete" &&
+        session.status !== "abandoned")
+        throw new Error("Workflow session status must be active, complete, or abandoned.");
     assertTimestamp(session.startedAt);
     assertTimestamp(session.updatedAt);
     if (session.lane !== undefined && session.lane !== "light")
@@ -281,12 +316,21 @@ function validateWorkflowSession(session) {
         if (!session.laneEscalationReason)
             throw new Error("Lane escalation requires a reason.");
     }
+    if (session.status === "abandoned" && !session.abandonedReason)
+        throw new Error("Abandoned sessions require an abandonment reason.");
 }
 function withStage(ledger, stage, record) {
     return {
         schema: 1,
         workflowId: ledger.workflowId,
         stages: { ...ledger.stages, [stage]: record },
+        // Preserve lane/process provenance: dropping them here silently stripped
+        // the process from the ledger on every stage transition (found by the
+        // OPP-009 sweep — the bug made bugfix workflows gate like feature ones).
+        ...(ledger.lane === "light" && ledger.laneReason
+            ? { lane: ledger.lane, laneReason: ledger.laneReason }
+            : {}),
+        ...(ledger.process && ledger.process !== "feature" ? { process: ledger.process } : {}),
     };
 }
 function isApprovalStage(value) {
@@ -356,7 +400,7 @@ function validateLedger(ledger) {
             throw new Error(`Approval ledger has unknown workflow stage: ${stage}.`);
         parseStageRecord(stage, record);
     }
-    for (const stage of APPROVAL_STAGES) {
+    for (const stage of processStages(ledger)) {
         const status = ledger.stages[stage]?.status;
         if (status === "pending-human" ||
             status === "approved" ||

package/dist/orchestration.d.ts

@@ -5,6 +5,8 @@ export type OrchestrationTask = {
     agent: OrchestrationAgent;
     prompt: string;
     dependsOn: string[];
+    /** Set by `orchestrate --isolate`: the per-task git worktree the adapter must run in (OPP-010). */
+    worktree?: string;
 };
 export type OrchestrationPlan = {
     schema: 1;
@@ -15,7 +17,36 @@ export type OrchestrationTaskResult = {
     id: string;
     status: "passed" | "failed" | "blocked";
     detail: string;
+    /** OPP-010 isolation evidence, present when the plan ran with --isolate. */
+    worktree?: string;
+    baseCommit?: string;
+    finalCommit?: string;
 };
+export type IsolationOptions = {
+    /** Repository root the plan runs in. */
+    root: string;
+    /** AI Workflow state directory (usually `.aiw`). */
+    aiw: string;
+    planId: string;
+};
+export declare function worktreeDirectory(aiw: string, planId: string, taskId: string): string;
+/**
+ * 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 declare function createTaskWorktrees(root: string, aiw: string, plan: OrchestrationPlan): Map<string, {
+    worktree: string;
+    baseCommit: string;
+}>;
+/** Final commit recorded from an isolated worktree (evidence for the checkpoint). */
+export declare function worktreeFinalCommit(worktree: string): string | undefined;
+/** Remove isolated worktrees; failed-task worktrees are kept unless forced. */
+export declare function removeWorktrees(root: string, paths: Iterable<string>, options?: {
+    force?: boolean;
+}): void;
+/** List isolated worktrees managed under `<aiw>/worktrees` (for cleanup/doctor). */
+export declare function listManagedWorktrees(root: string, aiw: string): string[];
 export interface AgentOrchestrator {
     run(task: OrchestrationTask): Promise<{
         success: boolean;
@@ -24,7 +55,13 @@ export interface AgentOrchestrator {
 }
 export declare function parseOrchestrationPlan(content: string): OrchestrationPlan;
 export declare function orchestrationWaves(plan: OrchestrationPlan): string[][];
-export declare function executeOrchestrationPlan(plan: OrchestrationPlan, orchestrator: AgentOrchestrator, maxParallel: number): Promise<OrchestrationTaskResult[]>;
+export declare function executeOrchestrationPlan(plan: OrchestrationPlan, orchestrator: AgentOrchestrator, maxParallel: number, isolation?: {
+    options: IsolationOptions;
+    worktrees: Map<string, {
+        worktree: string;
+        baseCommit: string;
+    }>;
+}): Promise<OrchestrationTaskResult[]>;
 export declare function validateOrchestrationParallelism(value: number): number;
 export declare function serializeOrchestrationPreview(plan: OrchestrationPlan): string;
 export declare function serializeOrchestrationResults(plan: OrchestrationPlan, results: OrchestrationTaskResult[]): string;

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);