opencode-swarm 7.139.2 → 7.139.4

package/dist/cli/{worktree-collision-ownership-vexb0b6r.js → worktree-collision-ownership-hs5c2qzp.js}

@@ -3,26 +3,26 @@ import {
   WORKTREE_PROVISIONING_OWNER_LEASE_MS,
   removeWorktreeProvisioningOwner,
   scanWorktreeProvisioningOwnersForRecovery
-} from "./index-q7ezzgwq.js";
+} from "./index-1kyex7z2.js";
 import {
   scanWorktreeMergeFailuresForRecovery
 } from "./index-b8zgtz81.js";
 import {
   scanDelegationFallbacksForRecovery,
   scanDelegationsForRecovery
-} from "./index-prmb5qfp.js";
-import"./index-x9q4bbhd.js";
+} from "./index-j77frjq8.js";
+import"./index-k46me75h.js";
+import"./index-ee3x66a5.js";
 import"./index-ed5ykebp.js";
-import"./index-5j6chvj8.js";
+import"./index-s0qc4gj6.js";
 import"./index-7g4c7s5r.js";
-import"./index-a5eba0t8.js";
-import"./index-bpmtbmy9.js";
-import"./index-z6xqpmqg.js";
-import"./index-zjygnfay.js";
 import {
   bunSpawn
-} from "./index-y111zefa.js";
+} from "./index-4nt52yr9.js";
 import"./index-zgwm4ryv.js";
+import"./index-zjygnfay.js";
+import"./index-rsrx77fg.js";
+import"./index-bpmtbmy9.js";
 import"./index-a76rekgs.js";
 
 // src/hooks/delegation-gate/worktree-collision-ownership.ts

package/dist/commands/approve-plan-critic.d.ts

@@ -5,8 +5,8 @@
  * gate (issue #2012). When the critic returns APPROVED but the mechanical
  * snapshot recorder fails to persist it (verdict-format mismatch, dispatch-
  * signal miss, or a plan.json read race), the gate permanently blocks ALL
- * coder delegations because `critic_pre_plan` defaults to `true` and cannot be
- * disabled. This records a manual `plan_critic_gate` approval snapshot so the
+ * coder delegations when the effective `critic_pre_plan` gate is enabled. This
+ * records a manual `plan_critic_gate` approval snapshot so the
  * gate unblocks, with a distinct `method: 'manual_override'` audit marker.
  *
  * The command is `toolPolicy: 'restricted'` — the agent cannot run it via

package/dist/commands/registry.d.ts

@@ -627,7 +627,7 @@ export declare const COMMAND_REGISTRY: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Record a MANUAL plan-critic approval to unblock the critic_pre_plan execution gate [reason...]";
         readonly args: "[reason...]";
-        readonly details: "Human-only escape hatch for the ratchet-tighter critic_pre_plan execution gate (issue #2012). When the critic already returned APPROVED but the mechanical snapshot recorder failed to persist it (verdict-format mismatch, dispatch-signal miss, or a plan.json read race), the gate permanently blocks ALL coder delegations because critic_pre_plan defaults to true and cannot be disabled. Running this records a manual plan_critic_gate approval snapshot so the gate unblocks, with a distinct method: \"manual_override\" audit marker. The agent itself cannot run this command; it must call the approve_plan_critic tool (or ask you to run this command). Both paths funnel into the same forceRecordPlanCriticApproval hook, which requires an active architect session. An audit event is appended to .swarm/events.jsonl. Prefer re-running MODE: CRITIC-GATE first; use this only as an escape hatch when a legitimate APPROVED was lost.";
+        readonly details: "Human-only escape hatch for the ratchet-tighter critic_pre_plan execution gate (issue #2012). When the critic already returned APPROVED but the mechanical snapshot recorder failed to persist it (verdict-format mismatch, dispatch-signal miss, or a plan.json read race), an enabled critic_pre_plan gate blocks coder delegation. Running this records a manual plan_critic_gate approval snapshot so the gate unblocks, with a distinct method: \"manual_override\" audit marker. The agent itself cannot run this command; it must call the approve_plan_critic tool (or ask you to run this command). Both paths funnel into the same forceRecordPlanCriticApproval hook, which requires an active architect session. An audit event is appended to .swarm/events.jsonl. Prefer re-running MODE: CRITIC-GATE first; use this only as an escape hatch when a legitimate APPROVED was lost.";
         readonly category: "utility";
         readonly toolPolicy: "restricted";
     };

package/dist/config/agent-model.d.ts

@@ -0,0 +1,35 @@
+import type { PluginConfig } from './schema';
+export interface ParsedAgentModel {
+    modelID: string;
+    providerID?: string;
+}
+type RegisteredAgentModel = {
+    model?: unknown;
+    mode?: unknown;
+};
+/** Split a supported legacy `provider/model/variant` value like registration does. */
+export declare function splitEmbeddedAgentVariant(model: string): {
+    model: string;
+    variant?: string;
+};
+/**
+ * Return only an explicit, nonblank model for an exact generated agent target.
+ * Unknown swarm prefixes and agent names fail closed instead of borrowing a
+ * similarly named role from another swarm.
+ */
+export declare function resolveConfiguredAgentModel(config: PluginConfig, exactAgentName: string): string | undefined;
+/** Resolve the registered model for an exact generated agent target. */
+export declare function resolveRegisteredAgentModel(config: PluginConfig, exactAgentName: string): string | undefined;
+/**
+ * Resolve the model that an exact generated agent will actually receive.
+ *
+ * Primary agents intentionally omit their registered model so OpenCode's UI
+ * controls selection; their live assistant metadata remains authoritative.
+ * Subagents use a runtime-mutated explicit model (including guardrail fallback)
+ * before the factory-resolved registered model, which also preserves inherited
+ * role defaults such as curator -> explorer.
+ */
+export declare function resolveRuntimeAgentModel(config: PluginConfig, registeredAgents: Record<string, RegisteredAgentModel>, exactAgentName: string): string | undefined;
+/** Parse model-only or provider/model config values without partial fallback. */
+export declare function parseAgentModel(model: string): ParsedAgentModel | undefined;
+export {};

package/dist/db/qa-gate-profile.d.ts

@@ -19,6 +19,7 @@ export declare const _internals: {
     getEffectiveGates: typeof getEffectiveGates;
     computeProfileHash: typeof computeProfileHash;
     hasAnyProfileWithEnabledGate: typeof hasAnyProfileWithEnabledGate;
+    afterSetGatesRead: (profile: QaGateProfile) => void;
 };
 /**
  * QA gate flags. All eleven gates are tracked explicitly.
@@ -74,9 +75,15 @@ export declare function getProfile(directory: string, planId: string): QaGatePro
 export declare function hasAnyProfileWithEnabledGate(directory: string, gate: keyof QaGates): boolean;
 /**
  * Return the existing profile for `planId`, or create a new one seeded with
- * `DEFAULT_QA_GATES` if none exists. Tolerates races on the UNIQUE index.
+ * `DEFAULT_QA_GATES` plus the caller's initial gate selection if none exists.
+ *
+ * `initialGates` is applied only by the winning INSERT. A caller that loses a
+ * UNIQUE-index race receives the winner's profile unchanged and must still run
+ * `setGates` to apply the normal ratchet rules. This lets the first architect
+ * selection turn default-on gates off without giving a later/concurrent caller
+ * a way to loosen an already-persisted `true` gate.
  */
-export declare function getOrCreateProfile(directory: string, planId: string, projectType?: string): QaGateProfile;
+export declare function getOrCreateProfile(directory: string, planId: string, projectType?: string, initialGates?: Partial<QaGates>): QaGateProfile;
 /**
  * Update gates for `planId`. Gates can only be ratcheted tighter —
  * attempting to disable a currently-enabled gate throws. Throws if the
@@ -112,7 +119,8 @@ export declare function computeProfileHash(profile: QaGateProfile): string;
  * - council_mode — src/state.ts isCouncilGateActive + src/hooks/delegation-gate.ts
  *   (replaces per-task Stage B with full 5-member council via submit_council_verdicts).
  * - sme_enabled — consumed during MODE: BRAINSTORM/SPECIFY architect dialogue.
- * - critic_pre_plan — consumed by MODE: PLAN critic delegation before save_plan.
+ * - critic_pre_plan — src/hooks/delegation-gate.ts (blocks coder delegation
+ *   until plan-critic approval when the effective gate is enabled).
  * - sast_enabled — consumed inside pre_check_batch tool.
  * - hallucination_guard — src/tools/phase-complete.ts Gate 3 (blocks phase_complete
  *   until .swarm/evidence/{phase}/hallucination-guard.json has APPROVED verdict).

package/dist/evidence/manager.d.ts

@@ -1,3 +1,4 @@
+import { realpathSync, statSync } from 'node:fs';
 import { type BuildEvidence, type Evidence, type EvidenceBundle, type PlaceholderEvidence, type QualityBudgetEvidence, type SastEvidence, type SbomEvidence, type SecretscanEvidence, type SyntaxEvidence } from '../config/evidence-schema';
 import { type EvaluationRetentionResult } from '../evaluation/retention.js';
 import { type DocumentsRetentionResult, pruneEvidenceDocuments } from './documents-retention.js';
@@ -66,7 +67,7 @@ export declare function isQualityBudgetEvidence(evidence: Evidence): evidence is
 export declare function isSecretscanEvidence(evidence: Evidence): evidence is SecretscanEvidence;
 import { sanitizeTaskId as _sanitizeTaskId } from '../validation/task-id';
 export declare const sanitizeTaskId: typeof _sanitizeTaskId;
-/** Maximum depth to walk up the directory tree before stopping (fail-open). */
+/** Maximum depth to walk up the directory tree before failing closed. */
 export declare const MAX_DEPTH = 20;
 /** File/directory names that indicate a real project root. */
 export declare const PROJECT_INDICATORS: readonly ["package.json", ".git", ".opencode", "Cargo.toml", "go.mod", "pyproject.toml", "Gemfile", "composer.json", "pom.xml", "build.gradle", "CMakeLists.txt"];
@@ -85,7 +86,7 @@ export declare function validateProjectRoot(directory: string): void;
  * Performs atomic write via temp file + rename.
  * @throws Error if task ID is invalid or size limit would be exceeded
  */
-export declare function saveEvidence(directory: string, taskId: string, evidence: Evidence): Promise<EvidenceBundle>;
+export declare function saveEvidence(directory: string, taskId: string, evidence: Evidence, abortSignal?: AbortSignal): Promise<EvidenceBundle>;
 /**
  * Transform a flat retrospective object into a valid EvidenceBundle.
  */
@@ -172,6 +173,8 @@ export declare const _internals: {
     saveEvidence: typeof saveEvidence;
     deleteEvidence: typeof deleteEvidence;
     pruneEvidenceDocuments: typeof pruneEvidenceDocuments;
+    realpathSync: typeof realpathSync;
+    statSync: typeof statSync;
     now: () => Date;
 };
 export {};

package/dist/evidence/phase-participation.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Durable, phase-bound proof that a required swarm role completed successfully.
+ *
+ * Foreground Task calls are correlated in memory only until their terminal
+ * tool.execute.after event. Background calls promote the same reservation to
+ * this store's durable pending list and are completed only by the trusted
+ * background completion observer.
+ */
+import type { BackgroundDelegationRecord } from '../background/pending-delegations.js';
+import { type Plan } from '../config/plan-schema.js';
+export declare const PHASE_PARTICIPATION_FILE = "evidence/phase-participation.json";
+export declare const PHASE_PARTICIPATION_QUARANTINE_DIR = "evidence/phase-participation-quarantine";
+export declare const MAX_PHASE_PARTICIPATION_BYTES: number;
+export declare const MAX_PHASE_PARTICIPATION_PENDING = 128;
+export declare const MAX_PHASE_PARTICIPATION_RECEIPTS = 128;
+export declare const MAX_PHASE_PARTICIPATION_QUARANTINE_FILES = 16;
+export declare const MAX_PHASE_PARTICIPATION_QUARANTINE_BYTES: number;
+export declare const MAX_PHASE_PARTICIPATION_QUARANTINE_DIRECTORY_ENTRIES = 64;
+export interface ParticipationReadResult {
+    status: 'missing' | 'valid' | 'corrupt' | 'unreadable' | 'oversized';
+    found: boolean;
+}
+export declare function reserveApprovedPhaseParticipation(input: {
+    directory: string;
+    tool: string;
+    parentSessionId: string;
+    callId: string;
+    args: Record<string, unknown>;
+    policy: unknown;
+}): Promise<void>;
+export declare function observePhaseParticipationToolResult(input: {
+    directory: string;
+    tool: string;
+    parentSessionId: string;
+    callId: string;
+    output: unknown;
+}): Promise<void>;
+export declare function completeBackgroundPhaseParticipation(input: {
+    directory: string;
+    record: BackgroundDelegationRecord;
+    resultText: string;
+}): Promise<boolean>;
+export declare function readPhaseParticipation(directory: string, plan: Plan, phase: number, role: string): ParticipationReadResult;
+export declare function resetPhaseParticipationForTests(): void;

package/dist/hooks/compaction-customizer.d.ts

@@ -1,11 +1,39 @@
 /**
  * Compaction Customizer Hook
  *
- * Enhances session compaction by injecting swarm context from plan.md and context.md.
- * Adds current phase information and key decisions to the compaction context.
+ * Enhances session compaction by injecting bounded, summary-only swarm facts.
  */
+import * as fs from 'node:fs';
 import type { PluginConfig } from '../config';
+interface CompactionFact {
+    label: string;
+    value: string;
+}
+declare function countStoredOutputs(directory: string): Promise<{
+    count: number;
+    truncated: boolean;
+} | null>;
+/**
+ * Build one bounded block so the host never receives a partially-delimited set
+ * of plugin facts. The caller appends this block atomically to output.context.
+ */
+declare function buildCompactionFactsBlock(facts: CompactionFact[]): string;
 /**
  * Creates the experimental.session.compacting hook for compaction customization.
  */
 export declare function createCompactionCustomizerHook(config: PluginConfig, directory: string): Record<string, unknown>;
+export declare const _test_exports: {
+    buildCompactionFactsBlock: typeof buildCompactionFactsBlock;
+    compactionFs: {
+        lstat: typeof fs.promises.lstat;
+        realpath: typeof fs.promises.realpath;
+        opendir: typeof fs.promises.opendir;
+    };
+    countStoredOutputs: typeof countStoredOutputs;
+    MAX_COMPACTION_FACT_CHARS: number;
+    MAX_COMPACTION_CONTEXT_CHARS: number;
+    MAX_STORED_OUTPUTS_TO_COUNT: number;
+    COMPACTION_FACTS_OPEN: string;
+    COMPACTION_FACTS_CLOSE: string;
+};
+export {};

package/dist/hooks/context-budget.d.ts

@@ -36,7 +36,7 @@ interface MessageWithParts {
  * Injects warnings when context usage exceeds configured thresholds.
  * Only operates on messages for the architect agent.
  */
-export declare function createContextBudgetHandler(config: PluginConfig): (_input: Record<string, never>, _output: {
+export declare function createContextBudgetHandler(config: PluginConfig, resolveAgentModel?: (agentName: string) => string | undefined): (_input: Record<string, never>, _output: {
     messages?: MessageWithParts[];
 }) => Promise<void>;
 export {};

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

@@ -288,9 +288,9 @@ export declare function isPlanCriticApproved(directory: string): Promise<boolean
  * When the critic returns APPROVED but the mechanical snapshot recorder
  * ({@link recordPlanCriticApprovalSnapshotIfApplicable}) fails to persist it
  * (verdict-format mismatch, dispatch-signal miss, or a plan.json read race),
- * the gate permanently blocks ALL coder delegations because `critic_pre_plan`
- * defaults to `true` and cannot be disabled (ratchet-tighter). This records a
- * manual `plan_critic_gate` approval snapshot so the gate unblocks, with a
+ * the gate blocks coder delegations when the effective `critic_pre_plan`
+ * policy is enabled. This records a manual `plan_critic_gate` approval snapshot
+ * so the gate unblocks, with a
  * distinct `method: 'manual_override'` audit marker so a human or downstream
  * review can distinguish a manual approval from a mechanical critic approval.
  *

package/dist/hooks/guardrails/index.d.ts

@@ -21,6 +21,10 @@ export declare const _internals: {
     dcCheckJunctionCreation: typeof dcCheckJunctionCreation;
     extractErrorSignal: typeof extractErrorSignal;
     getSandboxExecutor: typeof getExecutor;
+    /** Test-only compatibility for legacy direct-after hook tests. */
+    allowUncorrelatedGateReceipts: boolean;
+    MAX_PENDING_GATE_RECEIPTS_PER_SESSION: number;
+    MAX_PENDING_GATE_RECEIPT_SESSIONS: number;
     /**
      * Test/inspection seams for the no-op detector's bounded session state
      * (invariant 8). Production code does not call these; they exist so the
@@ -82,7 +86,7 @@ export { redactShellCommand } from './helpers';
  * @param config Guardrails configuration (optional)
  * @returns Tool before/after hooks and messages transform hook
  */
-export declare function createGuardrailsHooks(directory: string, directoryOrConfig?: string | GuardrailsConfig, config?: GuardrailsConfig, authorityConfig?: AuthorityConfig, worktreeBaseDirOverrides?: string[]): {
+export declare function createGuardrailsHooks(directory: string, directoryOrConfig?: string | GuardrailsConfig, config?: GuardrailsConfig, authorityConfig?: AuthorityConfig, worktreeBaseDirOverrides?: string[], resolveAgentModel?: (agentName: string) => string | undefined): {
     toolBefore: (input: {
         tool: string;
         sessionID: string;

package/dist/hooks/guardrails/messages-transform.d.ts

@@ -33,6 +33,8 @@ export interface MessagesTransformContext {
      * explanation for the silence.
      */
     lastCountedAssistantMsgId: Map<string, string>;
+    /** Resolve an explicit model for the exact incoming agent, when available. */
+    resolveAgentModel?: (agentName: string) => string | undefined;
 }
 type ChatMessageLike = {
     /**

package/dist/hooks/guardrails/pre-check-result.d.ts

@@ -0,0 +1,20 @@
+export type PreCheckVerdict = {
+    kind: 'pass';
+} | {
+    kind: 'fail';
+    code: 'PRE_CHECK_FAILED' | 'PRE_CHECK_INPUT_INVALID';
+} | {
+    kind: 'skip';
+} | {
+    kind: 'invalid';
+    code: 'PRE_CHECK_RESULT_INVALID';
+};
+/**
+ * Decode the public pre_check_batch result without treating nested text as
+ * control data. Unknown, oversized, truncated, or contradictory shapes are
+ * non-passing and receive one bounded diagnostic code.
+ */
+export declare function decodePreCheckResult(output: unknown): PreCheckVerdict;
+export declare const _internals: {
+    MAX_PRE_CHECK_RESULT_BYTES: number;
+};