opencode-swarm 7.121.0 → 7.121.1

package/dist/cli/{index-3ygv9535.js → index-k7gvykn4.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-3je67dcz.js";
+} from "./index-8cp19x15.js";
 import {
   handleGuardrailLog
 } from "./index-zvae4m8g.js";
@@ -83,7 +83,7 @@ import {
   handleWriteRetroCommand,
   normalizeSwarmCommandInput,
   resolveCommand
-} from "./index-gmc34yzt.js";
+} from "./index-e7yqazk3.js";
 import"./index-kyvg2cmp.js";
 import"./index-vqcgmy4y.js";
 import"./index-j5xv8zbp.js";

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import {
   getPluginLockFilePaths,
   package_default,
   resolveCommand
-} from "./index-gmc34yzt.js";
+} from "./index-e7yqazk3.js";
 import"./index-kyvg2cmp.js";
 import"./index-vqcgmy4y.js";
 import"./index-j5xv8zbp.js";

package/dist/commands/issue.d.ts

@@ -10,4 +10,16 @@
  *   --no-repro    → appends noRepro=true to emitted signal
  *   no args       → returns usage string (no throw)
  */
+import * as fs from 'node:fs';
+/**
+ * DI seam for filesystem operations — allows tests to override synchronous fs calls.
+ */
+export declare const _internals: {
+    writeFileSync: typeof fs.writeFileSync;
+    mkdirSync: typeof fs.mkdirSync;
+    renameSync: typeof fs.renameSync;
+    unlinkSync: typeof fs.unlinkSync;
+    readFileSync: typeof fs.readFileSync;
+    existsSync: typeof fs.existsSync;
+};
 export declare function handleIssueCommand(directory: string, args: string[]): string;

package/dist/hooks/delegation-gate.d.ts

@@ -101,6 +101,11 @@ interface MessageWithParts {
     info: MessageInfo;
     parts: MessagePart[];
 }
+/**
+ * Returns whether the plan in the given directory has a valid plan-critic
+ * approval. Does not throw — returns `false` for any failure (fail-closed).
+ */
+export declare function isPlanCriticApproved(directory: string): Promise<boolean>;
 declare function resolveDelegatedPlanTaskId(args: Record<string, unknown>, knownPlanTaskIds?: ReadonlySet<string>): string | null;
 /**
  * Parses structured per-task verdict lines from agent dispatch output.

package/dist/hooks/issue-trace-reducer.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Issue trace reducer — a pure transition function with zero I/O.
+ *
+ * Determines the next mode transition for an issue-trace workflow
+ * based on current trace state and workflow artifacts. Evaluated
+ * top-to-bottom (first-match-wins) against an 8-row decision table.
+ */
+export interface IssueReference {
+    url: string;
+    owner: string;
+    repo: string;
+    number: number;
+    timestamp: string;
+    flags: {
+        plan?: boolean;
+        trace?: boolean;
+        noRepro?: boolean;
+    };
+    noReproWaiver?: {
+        waived: boolean;
+        reason: string;
+        timestamp: string;
+    };
+}
+export interface TraceState {
+    issueNumber: number;
+    lastTransition: string | null;
+    completed: boolean;
+}
+export interface WorkflowArtifacts {
+    specExists: boolean;
+    specIssueNumber: number | null;
+    planExists: boolean;
+    criticApproved: boolean;
+    allPhasesComplete: boolean;
+}
+export interface TransitionResult {
+    nextMode: string | null;
+    directive: string | null;
+    nextLastTransition: string | null;
+    nextCompleted: boolean;
+}
+export interface ComputeNextModeParams {
+    issueReference: IssueReference | null;
+    traceState: TraceState;
+    workflowArtifacts: WorkflowArtifacts;
+}
+/**
+ * Pure reducer: given trace state + workflow artifacts, return the
+ * next mode transition (or a no-op).
+ *
+ * Decision table (top-to-bottom, first match wins):
+ *   (a) No issue reference or trace not requested        → no-op
+ *   (b) Trace already completed                           → no-op
+ *   (c) Cross-issue guard (spec issue ≠ current issue)   → no-op
+ *   (d) Spec does not exist                              → no-op
+ *   (e) Spec exists, no plan, never transitioned          → PLAN
+ *   (f) Plan exists but critic not approved               → no-op
+ *   (g) Critic approved, phases incomplete, not yet PLAN_TO_EXECUTE → EXECUTE
+ *   (h) All phases complete, not yet EXECUTE_TO_COMMIT    → COMMIT directive
+ *
+ * Idempotency: rows (e), (g), (h) return no-op when
+ * `traceState.lastTransition` already equals the target
+ * transition value.
+ */
+export declare function computeNextMode(params: ComputeNextModeParams): TransitionResult;

package/dist/hooks/issue-trace-state.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Issue trace state adapter — reads and writes all artifacts for the
+ * issue-trace workflow engine.
+ *
+ * Uses the `_internals` DI seam pattern (AGENTS.md invariant 7) so
+ * tests can override filesystem calls without `mock.module` leakage.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import type { Plan } from '../config/plan-schema';
+import type { IssueReference, TraceState } from './issue-trace-reducer';
+declare function _defaultLoadPlanFromLedger(directory: string): Promise<Plan | null>;
+export declare const _internals: {
+    readFileSync: typeof readFileSync;
+    writeFileSync: typeof writeFileSync;
+    existsSync: typeof existsSync;
+    renameSync: typeof renameSync;
+    mkdirSync: typeof mkdirSync;
+    unlinkSync: typeof unlinkSync;
+    loadPlanFromLedger: typeof _defaultLoadPlanFromLedger;
+};
+/**
+ * Reads `.swarm/issue-reference.json` and returns the parsed object,
+ * or null if the file is absent or malformed.
+ */
+export declare function readIssueReference(directory: string): IssueReference | null;
+/**
+ * Reads `.swarm/issue-trace-state.json` and returns the parsed state,
+ * or a default `{issueNumber:0, lastTransition:null, completed:false}`
+ * if the file is absent or malformed.
+ */
+export declare function readTraceState(directory: string): TraceState;
+/**
+ * Writes `.swarm/issue-trace-state.json` atomically: creates a temp file
+ * inside `.swarm/`, writes JSON, then renames. Cleans up the temp on failure.
+ */
+export declare function writeTraceState(directory: string, state: TraceState): void;
+/**
+ * Reads `.swarm/spec.md` and extracts the issue number from the
+ * `## Source Issue` section. Looks for `- Number: N` or `- URL: ...issues/N`
+ * under the heading. Returns null if the section is absent or the number
+ * is unparseable.
+ */
+export declare function readSpecIssueNumber(directory: string): number | null;
+/**
+ * Loads the plan from the ledger-aware plan loader.
+ * Async because the underlying ledger loader is async.
+ */
+export declare function loadPlanFromLedger(directory: string): Promise<Plan | null>;
+/**
+ * Checks whether all phases in the plan have a completed status.
+ * Returns `{allComplete: false}` if the plan is null.
+ */
+export declare function readPlanPhaseStatus(directory: string): Promise<{
+    allComplete: boolean;
+}>;
+/**
+ * Returns whether `.swarm/spec.md` exists.
+ */
+export declare function specExists(directory: string): boolean;
+/**
+ * Returns whether `.swarm/plan.json` exists.
+ */
+export declare function planExists(directory: string): boolean;
+export {};

package/dist/hooks/issue-trace.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Issue trace hook — the deterministic trace transition engine.
+ *
+ * Ties together the reducer (issue-trace-reducer), the state adapter
+ * (issue-trace-state), and the approval helper (delegation-gate) into
+ * a single `messagesTransform` hook that the composeHandlers chain
+ * calls on every architect message cycle.
+ *
+ * Uses the `_internals` DI seam pattern (AGENTS.md invariant 7) so
+ * tests can override adapter functions without `mock.module` leakage.
+ */
+import { isPlanCriticApproved } from './delegation-gate';
+import { planExists, readIssueReference, readPlanPhaseStatus, readSpecIssueNumber, readTraceState, specExists, writeTraceState } from './issue-trace-state';
+export declare const _internals: {
+    readIssueReference: typeof readIssueReference;
+    readTraceState: typeof readTraceState;
+    writeTraceState: typeof writeTraceState;
+    readSpecIssueNumber: typeof readSpecIssueNumber;
+    readPlanPhaseStatus: typeof readPlanPhaseStatus;
+    specExists: typeof specExists;
+    planExists: typeof planExists;
+    isPlanCriticApproved: typeof isPlanCriticApproved;
+};
+export declare function createIssueTraceHook(_config: unknown, directory: string, approvalTimeoutMs?: number): {
+    messagesTransform: (input: unknown, output: unknown) => Promise<void>;
+};
+/**
+ * Reset the approval cache. Called by tests in afterEach to avoid
+ * cross-test pollution from the module-level cache.
+ */
+export declare function resetApprovalCache(): void;