opencode-swarm 7.181.0 → 7.181.1

package/dist/tools/index.d.ts

@@ -123,6 +123,7 @@ export { executeRecordImplementationReview, record_implementation_review, } from
 export { executeRecordIssuePublication, record_issue_publication, } from './record-issue-publication';
 export { executeRecordIssueReproduction, record_issue_reproduction, } from './record-issue-reproduction';
 export { executeRecordRecurrenceSweep, record_recurrence_sweep, } from './record-recurrence-sweep';
+export { executeRecoverReworkTask, recover_rework_task, } from './recover-rework-task';
 export { executeRunPrFeedbackStageA, run_pr_feedback_stage_a, } from './run-pr-feedback-stage-a';
 export { symbols } from './symbols';
 export { type SyntaxCheckFileResult, type SyntaxCheckInput, type SyntaxCheckResult, syntax_check, syntaxCheck, } from './syntax-check';

package/dist/tools/manifest.d.ts

@@ -48,6 +48,7 @@ export declare const TOOL_MANIFEST: {
     submit_pr_review_result: () => ToolDefinition;
     approve_plan_critic: () => ToolDefinition;
     approve_retry_sounding_board: () => ToolDefinition;
+    recover_rework_task: () => ToolDefinition;
     prepare_pr_workflow_checkout: () => ToolDefinition;
     record_implementation_review: () => ToolDefinition;
     record_issue_publication: () => ToolDefinition;

package/dist/tools/recover-rework-task.d.ts

@@ -0,0 +1,5 @@
+import { createSwarmTool } from './create-tool.js';
+export declare function executeRecoverReworkTask(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
+export declare const recover_rework_task: ReturnType<typeof createSwarmTool>;

package/dist/tools/tool-metadata.d.ts

@@ -177,6 +177,10 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: "architect"[];
     };
+    recover_rework_task: {
+        description: string;
+        agents: "architect"[];
+    };
     prepare_pr_workflow_checkout: {
         description: string;
         agents: "architect"[];

package/dist/workflow/rework-recovery.d.ts

@@ -0,0 +1,38 @@
+export interface ReworkRecoverySummary {
+    taskId: string;
+    generation: number;
+    state: string;
+    transitionId: string;
+    recordedAt: string;
+    /**
+     * Whether the stage_a_repair audit event actually landed in
+     * `.swarm/events.jsonl`. The durable transition is authoritative regardless;
+     * this surfaces the best-effort append honestly instead of asserting an
+     * audit record that may not exist (issue #2755 review, FB-001).
+     */
+    auditEventRecorded: boolean;
+}
+/**
+ * Architect-supervised recovery from `rework_required` (issue #2755).
+ *
+ * The mechanical `stage_a_passed` transition deliberately fails closed from
+ * `rework_required` (`TASK_WORKFLOW_CODER_MUTATION_REQUIRED`): a genuine code
+ * defect must go back through the coder. But a Stage B verdict that failed
+ * WITHOUT a code defect (e.g. a tool-argument mistake scored as a verdict —
+ * sibling issue #2756) strands a task whose code is correct, reviewed, and
+ * green on Stage A checks, with no agent-legal exit; the only other remedy
+ * ever offered is the human-only `/swarm recover`, whose repair leg skips
+ * this state entirely.
+ *
+ * This is the audited escape hatch the #2703 precedent
+ * (`approve_retry_sounding_board`) established for exactly this class: it
+ * writes the SAME durable transition the mechanical path would have written,
+ * admitted ONLY by the `supervisedRecovery` flag the reducer accepts from
+ * `rework_required`, and records a distinguishable `stage_a_repair` audit
+ * event (action `rework_recovered`). Every precondition fails closed; the
+ * mechanical path and the `/swarm recover` auto-scan are untouched.
+ */
+export declare function forceRecoverReworkTask(directory: string, sessionID: string, options: {
+    taskId: string;
+    reason?: string;
+}): Promise<ReworkRecoverySummary>;

package/dist/workflow/stage-a-repair.d.ts

@@ -21,12 +21,54 @@ export interface StageARepairResult {
     results: StageARepairOutcome[];
     truncated: boolean;
 }
+/**
+ * Appends a stage_a_repair lifecycle event to `.swarm/events.jsonl`.
+ * Mirrors coder-settlement's appendSettlementEvent contract: best-effort,
+ * never throws, appended through the canonical `appendCoreEventSync` seam
+ * (which owns `.swarm` creation, lock retry, and torn-tail framing — its
+ * single atomic append replaces the former EBUSY/EPERM one-retry), final
+ * failure surfaced via criticalWarn so a silently missing audit line is
+ * visible. Returns whether the audit line actually landed, so callers on
+ * supervised-write paths can surface audit honesty instead of asserting it
+ * (issue #2755 review: the recover_rework_task tool must not claim an audit
+ * record exists when the append failed).
+ */
+export declare function appendStageARepairEvent(directory: string, payload: Record<string, unknown>): Promise<boolean>;
 export type PreCheckGreennessResult = {
     green: true;
 } | {
     green: false;
     reason: 'no_pre_check_bundles' | 'pre_check_failed_or_stale';
 };
+/**
+ * Decides whether durable post-settlement Stage A proof exists for a wedged
+ * task. "Green" REQUIRES BOTH a secretscan evidence bundle whose latest entry
+ * is pass/approved/info with full coverage and zero findings, AND a sast_scan
+ * evidence bundle whose latest entry is pass/approved/info. Also requires
+ * every considered entry to be newer than the settlement commit when
+ * `settledAfterMs` is supplied (a scan taken before the coder's mutation
+ * proves nothing about it).
+ *
+ * Deliberately more conservative than `pre_check_batch`'s own default bar in
+ * two edge cases it cannot reproduce from persisted evidence alone: (1) a
+ * degraded-but-tolerated SAST run (Semgrep process failure with zero
+ * findings) persists an ordinary `verdict: 'fail'` entry structurally
+ * indistinguishable from a genuine failure — `failure_kind` is only present
+ * on the tool's transient return value, not the persisted bundle — so this
+ * function treats it as failing rather than risk silently waving through a
+ * scan that never actually completed; (2) a project running with SAST
+ * disabled (`sast_enabled: false`) never persists a `sast_scan` bundle at
+ * all, so a wedged task from such a project cannot be auto-repaired via this
+ * path and needs manual attention. Both are intentional fail-closed
+ * trade-offs for a security-relevant repair tool, not bugs — see PR #2316
+ * review finding ST-001/UIB-004 for why an absent-SAST-is-fine policy was
+ * removed in the first place.
+ *
+ * Evidence bucket names vs. entry type tags differ for SAST: the scanner
+ * persists its bundle under bucket `sast_scan` (see `src/tools/sast-scan.ts`)
+ * with individual entries tagged `type: 'sast'`.
+ */
+export declare function hasGreenPostSettlementPreCheck(directory: string, settledAfterMs: number | null): Promise<PreCheckGreennessResult>;
 export interface StageAScanResult {
     /** One entry per enumerated task, classified in the shared #2665 vocabulary. */
     results: TaskRecoveryStatus[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.181.0",
+	"version": "7.181.1",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",