opencode-swarm 7.111.0 → 7.112.1

package/dist/cli/{knowledge-store-dvjbdn00.js → knowledge-store-h3cjx4dg.js}

@@ -1,5 +1,6 @@
 // @bun
 import {
+  MAX_CONFIRMED_BY,
   OUTCOME_SIGNAL_SMOOTHING,
   _internals,
   appendKnowledge,
@@ -9,6 +10,7 @@ import {
   bumpKnowledgeConfidenceBatch,
   computeConfidence,
   computeOutcomeSignal,
+  confirmEntriesPhase,
   enforceKnowledgeCap,
   findNearDuplicate,
   getArchivedKnowledgeIds,
@@ -32,16 +34,16 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-v8pk35h7.js";
+} from "./index-32bx4kch.js";
 import"./index-bfwt3abw.js";
-import"./index-40h0yp9e.js";
+import"./index-db1fh1fv.js";
 import"./index-jtqkh8jf.js";
 import"./index-zgwm4ryv.js";
-import"./index-1cn967sa.js";
+import"./index-0dab9w37.js";
 import"./index-5mkc2f9z.js";
 import"./index-vn263hqt.js";
 import"./index-vvk2g744.js";
-import"./index-7xgqky26.js";
+import"./index-h91bv3hy.js";
 import"./index-a76rekgs.js";
 export {
   wordBigrams,
@@ -67,6 +69,7 @@ export {
   getArchivedKnowledgeIds,
   findNearDuplicate,
   enforceKnowledgeCap,
+  confirmEntriesPhase,
   computeOutcomeSignal,
   computeConfidence,
   bumpKnowledgeConfidenceBatch,
@@ -75,5 +78,6 @@ export {
   appendKnowledgeWithCapEnforcement,
   appendKnowledge,
   _internals,
-  OUTCOME_SIGNAL_SMOOTHING
+  OUTCOME_SIGNAL_SMOOTHING,
+  MAX_CONFIRMED_BY
 };

package/dist/cli/{knowledge-validator-bqr936sg.js → knowledge-validator-q6jw2p0t.js}

@@ -22,17 +22,17 @@ import {
   validateLesson,
   validateSkillCandidatePath,
   validateSkillPath
-} from "./index-c483hnn4.js";
-import"./index-v8pk35h7.js";
+} from "./index-30ejh1tx.js";
+import"./index-32bx4kch.js";
 import"./index-bfwt3abw.js";
-import"./index-40h0yp9e.js";
+import"./index-db1fh1fv.js";
 import"./index-jtqkh8jf.js";
 import"./index-zgwm4ryv.js";
-import"./index-1cn967sa.js";
+import"./index-0dab9w37.js";
 import"./index-5mkc2f9z.js";
 import"./index-vn263hqt.js";
 import"./index-vvk2g744.js";
-import"./index-7xgqky26.js";
+import"./index-h91bv3hy.js";
 import"./index-a76rekgs.js";
 export {
   validateSkillPath,

package/dist/cli/{pending-delegations-yyz3fcfn.js → pending-delegations-gc3a2hfx.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-r3j3458j.js";
+} from "./index-1rga1vvb.js";
 import"./index-jtqkh8jf.js";
 import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
@@ -17,7 +17,7 @@ import {
 } from "./index-5mkc2f9z.js";
 import"./index-vn263hqt.js";
 import"./index-vvk2g744.js";
-import"./index-7xgqky26.js";
+import"./index-h91bv3hy.js";
 import"./index-a76rekgs.js";
 
 // src/background/pending-delegations.ts

package/dist/cli/{pr-subscriptions-vv8byxe6.js → pr-subscriptions-p8g2rzxd.js}

@@ -9,8 +9,8 @@ import {
   sweepStale,
   unsubscribe,
   updateSnapshot
-} from "./index-85bacexr.js";
-import"./index-r3j3458j.js";
+} from "./index-q1jaeynn.js";
+import"./index-1rga1vvb.js";
 import"./index-jtqkh8jf.js";
 import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
@@ -19,7 +19,7 @@ import"./index-293f68mj.js";
 import"./index-5mkc2f9z.js";
 import"./index-vn263hqt.js";
 import"./index-vvk2g744.js";
-import"./index-7xgqky26.js";
+import"./index-h91bv3hy.js";
 import"./index-a76rekgs.js";
 export {
   updateSnapshot,

package/dist/cli/{schema-s48je8zt.js → schema-2p15yrvn.js}

@@ -86,7 +86,7 @@ import {
   resolveGeneratedAgentRole,
   resolveGuardrailsConfig,
   stripKnownSwarmPrefix
-} from "./index-0g5xsrp4.js";
+} from "./index-cq2hgvd2.js";
 import"./index-bfwt3abw.js";
 import"./index-p0arc26j.js";
 import"./index-293f68mj.js";

package/dist/cli/{scope-persistence-tgp00wtd.js → scope-persistence-5ccgtebg.js}

@@ -6,9 +6,9 @@ import {
   readScopeFromDisk,
   resolveScopeWithFallbacks,
   writeScopeToDisk
-} from "./index-vzzt3ygr.js";
+} from "./index-g55nzpwn.js";
 import"./index-vvk2g744.js";
-import"./index-7xgqky26.js";
+import"./index-h91bv3hy.js";
 import"./index-a76rekgs.js";
 export {
   writeScopeToDisk,

package/dist/cli/{skill-generator-5rsjmmfq.js → skill-generator-fe6q8xgm.js}

@@ -33,19 +33,19 @@ import {
   sanitizeSlug,
   selectCandidateEntries,
   writeEvalStub
-} from "./index-cmjq1kg7.js";
-import"./index-c483hnn4.js";
-import"./index-yhmt3dw3.js";
-import"./index-v8pk35h7.js";
+} from "./index-82v0d72f.js";
+import"./index-30ejh1tx.js";
+import"./index-hpp2r0sd.js";
+import"./index-32bx4kch.js";
 import"./index-bfwt3abw.js";
-import"./index-40h0yp9e.js";
+import"./index-db1fh1fv.js";
 import"./index-jtqkh8jf.js";
 import"./index-zgwm4ryv.js";
-import"./index-1cn967sa.js";
+import"./index-0dab9w37.js";
 import"./index-5mkc2f9z.js";
 import"./index-vn263hqt.js";
 import"./index-vvk2g744.js";
-import"./index-7xgqky26.js";
+import"./index-h91bv3hy.js";
 import"./index-a76rekgs.js";
 export {
   writeEvalStub,

package/dist/commands/ci-simulate.d.ts

@@ -1,16 +1,40 @@
+/**
+ * Handle /swarm ci-simulate command.
+ *
+ * Simulates CI by merging a PR branch into a temporary worktree created from
+ * the detected default remote branch (origin/main, origin/master, etc.), then
+ * running the full validation suite:
+ *   bun run typecheck
+ *   bun run lint
+ *   bun run build
+ *   bun test
+ *
+ * This reproduces the merge-group CI environment locally, catching integration
+ * failures (pass on PR branch, fail on merged result) before they cause
+ * merge-queue kick-outs.
+ *
+ * Input contract:
+ *   /swarm ci-simulate              → uses current HEAD branch
+ *   /swarm ci-simulate <pr-ref>     → uses the specified branch/ref
+ */
 import * as fs from 'node:fs';
-type RunResult = {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-    stdoutTruncated?: boolean;
-    stderrTruncated?: boolean;
-};
-declare function runCommand(cmd: string[], cwd: string, timeout: number): Promise<RunResult>;
+import { getDefaultBaseBranch } from '../git/branch.js';
+import { runExternalTool } from '../utils/external-tool-runner.js';
 export declare const _internals: {
-    runCommand: typeof runCommand;
-    now: () => number;
-    mkdirSync: typeof fs.mkdirSync;
+    runExternalTool: typeof runExternalTool;
+    getDefaultBaseBranch: typeof getDefaultBaseBranch;
+    platform: string;
+    osTmpdir: () => string;
+    fs: {
+        existsSync: typeof fs.existsSync;
+        rmSync: typeof fs.rmSync;
+    };
 };
+/**
+ * Handle /swarm ci-simulate command.
+ *
+ * @param directory - Project root (absolute path to the git working tree).
+ * @param args - Command arguments; first positional is the PR ref (optional).
+ * @returns Human-readable report string.
+ */
 export declare function handleCiSimulateCommand(directory: string, args: string[]): Promise<string>;
-export {};

package/dist/commands/pr-monitor-status.d.ts

@@ -31,11 +31,19 @@ declare function listMergeGroupRuns(directory: string, repoFullName: string, prN
     runs: MergeGroupRun[];
     error?: string;
 }>;
+/**
+ * Format merge-group run status for display.
+ *
+ * Shows the run status (queued/in_progress/completed), conclusion if available,
+ * and a link reference.
+ */
+declare function formatMergeGroupStatus(status?: string, conclusion?: string, htmlUrl?: string): string;
 /**
  * Exposed for unit testing via _internals.
  */
 export declare const _internals: {
     formatRelativeTime: typeof formatRelativeTime;
+    formatMergeGroupStatus: typeof formatMergeGroupStatus;
     listActive: typeof listActive;
     listMergeGroupRuns: typeof listMergeGroupRuns;
     parseMergeGroupRuns: typeof parseMergeGroupRuns;

package/dist/config/bundled-skills.d.ts

@@ -1,4 +1,4 @@
-export declare const BUNDLED_PROJECT_SKILLS: readonly ["brainstorm", "specify", "clarify-spec", "resume", "clarify", "discover", "consult", "pre-phase-briefing", "council", "deep-dive", "deep-research", "codebase-review-swarm", "swarm-implement", "design-docs", "swarm-pr-review", "swarm", "swarm-pr-feedback", "swarm-pr-subscribe", "swarm-ci-monitor", "issue-ingest", "plan", "critic-gate", "execute", "phase-wrap", "loop", "writing-tests", "running-tests", "engineering-conventions", "commit-pr", "worktree-retry-cleanup", "skill-edit-validation", "merge-queue-readiness", "gate-attribution", "ci-failure-batching"];
+export declare const BUNDLED_PROJECT_SKILLS: readonly ["brainstorm", "specify", "clarify-spec", "resume", "clarify", "discover", "consult", "pre-phase-briefing", "council", "deep-dive", "deep-research", "codebase-review-swarm", "swarm-implement", "design-docs", "swarm-pr-review", "swarm", "swarm-pr-feedback", "swarm-pr-subscribe", "swarm-ci-monitor", "issue-ingest", "plan", "critic-gate", "execute", "phase-wrap", "loop", "writing-tests", "running-tests", "engineering-conventions", "commit-pr", "ci-failure-batching", "gate-attribution", "merge-queue-readiness", "skill-edit-validation", "worktree-retry-cleanup"];
 interface CopyState {
     files: number;
     bytes: number;

package/dist/config/schema.d.ts

@@ -273,6 +273,7 @@ export declare const PlaceholderScanConfigSchema: z.ZodObject<{
     deny_patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
     allow_globs: z.ZodDefault<z.ZodArray<z.ZodString>>;
     max_allowed_findings: z.ZodDefault<z.ZodNumber>;
+    sentinel_allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type PlaceholderScanConfig = z.infer<typeof PlaceholderScanConfigSchema>;
 export declare const QualityBudgetConfigSchema: z.ZodObject<{
@@ -302,6 +303,7 @@ export declare const GateConfigSchema: z.ZodObject<{
         deny_patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
         allow_globs: z.ZodDefault<z.ZodArray<z.ZodString>>;
         max_allowed_findings: z.ZodDefault<z.ZodNumber>;
+        sentinel_allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     sast_scan: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -1622,6 +1624,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
             deny_patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
             allow_globs: z.ZodDefault<z.ZodArray<z.ZodString>>;
             max_allowed_findings: z.ZodDefault<z.ZodNumber>;
+            sentinel_allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
         sast_scan: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
@@ -2416,6 +2419,8 @@ export declare const PluginConfigSchema: z.ZodObject<{
             every_tool_calls: z.ZodDefault<z.ZodNumber>;
             every_architect_turns: z.ZodDefault<z.ZodNumber>;
             every_minutes: z.ZodDefault<z.ZodNumber>;
+            max_dispatch_retries: z.ZodDefault<z.ZodNumber>;
+            max_consecutive_dispatch_failures: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>>;
     pr_monitor: z.ZodOptional<z.ZodObject<{

package/dist/full-auto/oversight.d.ts

@@ -44,6 +44,10 @@ export interface DispatchFullAutoOversightInput {
      */
     fullAutoConfig?: {
         fail_closed?: boolean;
+        /** Override for max dispatch retries (default from schema: 2). */
+        max_dispatch_retries?: number;
+        /** Override for max consecutive dispatch failures (default from schema: 3). */
+        max_consecutive_dispatch_failures?: number;
     };
 }
 export declare function parseFullAutoCriticResponse(rawResponse: string): FullAutoCriticResult;
@@ -85,5 +89,4 @@ export declare function dispatchFullAutoOversight(input: DispatchFullAutoOversig
  */
 export declare const _internals: {
     resetSequence: () => void;
-    sleep: (ms: number) => Promise<void>;
 };

package/dist/full-auto/state.d.ts

@@ -13,6 +13,7 @@ export interface FullAutoCounters {
     testFailures: number;
     oversightChecks: number;
     consecutiveNoProgressTurns: number;
+    consecutiveOversightFailures: number;
 }
 export interface FullAutoRunState {
     status: FullAutoStatus;
@@ -34,6 +35,8 @@ export interface FullAutoRunState {
     counters: FullAutoCounters;
     pauseReason?: string;
     terminateReason?: string;
+    /** Consecutive oversight dispatch failures for auto-degrade. */
+    consecutiveOversightFailures?: number;
 }
 export interface FullAutoPersistedState {
     version: 2;
@@ -104,6 +107,15 @@ export declare function terminateFullAutoRun(directory: string, sessionID: strin
 export declare function isFullAutoRunActive(directory: string, sessionID: string): boolean;
 export type FullAutoCounterKey = keyof FullAutoCounters;
 export declare function incrementFullAutoCounter(directory: string, sessionID: string, counter: FullAutoCounterKey, delta?: number): FullAutoRunState | undefined;
+/**
+ * Increment the consecutive-oversight-failure counter.
+ * Returns the new value after incrementing.
+ */
+export declare function incrementOversightFailureCounter(directory: string, sessionID: string): number;
+/**
+ * Reset the consecutive-oversight-failure counter to 0.
+ */
+export declare function resetOversightFailureCounter(directory: string, sessionID: string): void;
 export declare function recordFullAutoDenial(directory: string, sessionID: string, denial: {
     tool?: string;
     code?: string;

package/dist/git/pr.d.ts

@@ -69,6 +69,7 @@ export declare const _internals: {
     spawnSyncWithTransientRetry: typeof spawnSyncWithTransientRetry;
     spawnSync: typeof __spawnSyncSeam.spawnSync;
     readLaneEnvFileFromDiskSync: typeof readLaneEnvFileFromDiskSync;
+    getMergeGroupRun: typeof getMergeGroupRun;
 };
 /**
  * Check if gh CLI is available
@@ -107,6 +108,7 @@ export interface PRStatusResult {
         name: string;
         status: string;
         conclusion: string | null;
+        detailsUrl?: string;
     }>;
 }
 export interface PRCheckResult {
@@ -156,4 +158,25 @@ export declare function getMergeState(prNumber: number, repoFullName: string, cw
  * Uses async ghExecAsync to avoid blocking the event loop.
  */
 export declare function getPRReviewState(prNumber: number, repoFullName: string, cwd: string): Promise<ReviewStateResult>;
+/**
+ * Result of fetching a GitHub Actions run for a PR's merge group.
+ */
+export interface MergeGroupRunResult {
+    /** Run status: queued, in_progress, completed. */
+    status: string;
+    /** Run conclusion: success, failure, cancelled, etc. */
+    conclusion: string | null;
+    /** HTML URL to the run. */
+    htmlUrl: string;
+}
+/**
+ * Fetch the merge group GitHub Actions run for a PR.
+ *
+ * Searches the PR's statusCheckRollup for the "Merge pull request" check,
+ * extracts the run ID from its detailsUrl, and fetches the run details
+ * via `gh run view`.
+ *
+ * Returns null if no merge group check is found (PR not in a merge queue).
+ */
+export declare function getMergeGroupRun(statusCheckRollup: PRStatusResult['statusCheckRollup'], repoFullName: string, cwd: string): Promise<MergeGroupRunResult | null>;
 export {};

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

@@ -9,6 +9,7 @@
  * The _internals seam allows test injection of worktree operations.
  */
 import type { PluginConfig, WorktreeIsolationConfig } from '../../config';
+import { bunSpawn } from '../../utils/bun-compat';
 import type { WorktreeHandle } from '../../worktree';
 import { attemptMergeBackFromDirty, cleanupOrphanedBranches, postMergeCleanup, provisionWorktree, removeWorktree, startupOrphanRecovery } from '../../worktree';
 /**
@@ -107,6 +108,38 @@ declare function rememberStandardWorktreeSerializationSession(sessionID: string)
 export declare function sanitizeWorktreeTaskId(raw: string): string;
 import { resolveWorktreeIsolationConfig } from '../../config/worktree-isolation-config';
 export { resolveWorktreeIsolationConfig };
+/**
+ * FR-001b SC-004: Runs `git worktree list --porcelain` and checks whether
+ * ANY registered worktree has a lane branch for the given taskId (regardless
+ * of which session owns it).
+ *
+ * The detection pattern matches both current `swarm/lane/<sessionId>/<taskId>`
+ * and legacy `swarm-lane/<sessionId>/<taskId>` branch formats.
+ *
+ * Returns collision info if any lane for this taskId is found registered in
+ * an active worktree. Does NOT check whether the worktree path is valid on
+ * disk — only whether the branch is checked out somewhere.
+ *
+ * @param taskId       - Task ID to detect collisions for.
+ * @param directory    - Project root (git working tree).
+ * @param sessionId    - Current session ID (used only to populate ownerSessionId
+ *                       in the collision result; NOT used for collision detection).
+ */
+export declare function preProvisionCollisionCheck(taskId: string, directory: string, _sessionId: string): Promise<{
+    collision: boolean;
+    existingBranch?: string;
+    ownerSessionId?: string;
+    worktreePath?: string;
+}>;
+/**
+ * FR-001b SC-005: Returns true when `branchName`'s embedded session ID matches
+ * `expectedSessionId`.
+ *
+ * Uses `extractSessionId` (merge.ts) to parse the branch name. Supports both
+ * legacy `swarm-lane/<sessionId>/<id>` and current `swarm/lane/<sessionId>/<id>`
+ * patterns.
+ */
+export declare function isLaneOwnedByCurrentSession(branchName: string, expectedSessionId: string): boolean;
 export declare function precreateStandardWorktreeSession(args: {
     config: PluginConfig;
     directory: string;
@@ -122,6 +155,68 @@ export declare function precreateStandardWorktreeSession(args: {
         files: string[];
     };
 }): Promise<void>;
+/**
+ * FR-001c: Preserves dirty work in a worktree before cleanup on denial or cancellation.
+ *
+ * Detects dirty state, auto-commits with a descriptive message, tags the commit,
+ * and returns the commit hash so the work is recoverable from the reflog.
+ *
+ * @returns Three distinct outcomes:
+ *   - `{ outcome: 'clean', preserved: false }` — worktree was clean; nothing to preserve.
+ *   - `{ outcome: 'preserved', preserved: true, ref: <hash> }` — dirty AND commit succeeded.
+ *   - `{ outcome: 'preserve-failed', preserved: false, error: <msg> }` — dirty AND commit/tag failed.
+ */
+export declare function preserveDirtyWorktreeForCallId(callID: string, reason: 'denied' | 'cancelled', _directory: string, _worktree_dir?: string): Promise<{
+    outcome: 'clean' | 'preserved' | 'preserve-failed';
+    preserved: false | true;
+    ref?: string;
+    error?: string;
+}>;
+/**
+ * FR-001b SC-004: Preserves dirty worktree state at a known worktree path.
+ *
+ * This is the path-based counterpart of `preserveDirtyWorktreeForCallId` for the
+ * pre-provision collision fallback path where the callID is no longer tracked in
+ * any map (dispatch was GC'd). It runs the same git status → add → commit → tag
+ * sequence on a direct worktreePath.
+ *
+ * @param worktreePath - Absolute path to the worktree directory.
+ * @param branchName - Branch name (used only for advisory messages).
+ * @param reason - Preservation reason: 'denied' (pre-provision collision) or 'cancelled'.
+ * @param directory - Project root for git commands.
+ * @param worktree_dir - Optional worktree-dir override.
+ * @returns Preservation result matching preserveDirtyWorktreeForCallId's shape.
+ */
+export declare function preserveDirtyWorktreeAtPath(worktreePath: string, branchName: string, reason: 'denied' | 'cancelled', _directory: string, _worktree_dir?: string): Promise<{
+    outcome: 'clean' | 'preserved' | 'preserve-failed';
+    preserved: false | true;
+    ref?: string;
+    error?: string;
+}>;
+/**
+ * FR-001a: Unconditionally cleans up a standard worktree dispatch's resources.
+ *
+ * Called at the end of every dispatch outcome (success, denial, cancellation)
+ * to ensure no worktree or branch is left behind.
+ *
+ * @param callID - The callID of the dispatch to clean up.
+ * @param reason - The outcome reason: 'success', 'denied', or 'cancelled'.
+ * @param directory - The project root (required for git worktree/branch commands).
+ * @param worktree_dir - Configured worktree-dir override.
+ */
+export declare function cleanupStandardWorktreeForCallId(callID: string, reason: 'success' | 'denied' | 'cancelled', directory: string, worktree_dir?: string): Promise<void>;
+/**
+ * FR-001a: Abort an in-flight standard worktree dispatch.
+ *
+ * Called when a dispatch needs to be cancelled before merge-back completes.
+ * Handles the case where the worktree was never provisioned (no entry in
+ * standardWorktreeByCallID) by returning early with a no-op diagnostic.
+ *
+ * @param callID - The callID of the dispatch to abort.
+ * @param reason - The abort reason: 'denied' or 'cancelled'.
+ * @param directory - The project root (required for git worktree/branch commands).
+ */
+export declare function abortStandardWorktreeDispatch(callID: string, reason: 'denied' | 'cancelled', directory: string): Promise<void>;
 export declare function finishStandardWorktreeDispatch(directory: string, dispatch: StandardWorktreeDispatch, config?: PluginConfig, 
 /**
  * Optional callID for cleanup of awaitingMergeByCallID. When omitted,
@@ -165,4 +260,19 @@ export declare const _internals: {
     awaitingMergeByCallID: Map<string, AwaitingMergeRecord>;
     startupOrphanRecovery: typeof startupOrphanRecovery;
     cleanupOrphanedBranches: typeof cleanupOrphanedBranches;
+    /** FR-001a: cleanup entry point for finishStandardWorktreeDispatch. */
+    cleanupStandardWorktreeForCallId: typeof cleanupStandardWorktreeForCallId;
+    /** FR-001c: preserves dirty worktree state before cleanup on denial/cancellation. */
+    preserveDirtyWorktreeForCallId: typeof preserveDirtyWorktreeForCallId;
+    /** FR-001b SC-004: path-based dirty worktree preservation for stale-lane fallback. */
+    preserveDirtyWorktreeAtPath: typeof preserveDirtyWorktreeAtPath;
+    /** FR-001a: abort entry point for in-flight dispatches. */
+    abortStandardWorktreeDispatch: typeof abortStandardWorktreeDispatch;
+    standardWorktreeByCallID: Map<string, StandardWorktreeDispatch>;
+    /** FR-001b SC-004: pre-provision collision check. */
+    preProvisionCollisionCheck: typeof preProvisionCollisionCheck;
+    /** FR-001b SC-005: lane ownership validation. */
+    isLaneOwnedByCurrentSession: typeof isLaneOwnedByCurrentSession;
+    /** FR-001b: bunSpawn — exposed for test injection so collision check can be mocked. */
+    bunSpawn: typeof bunSpawn;
 };

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

@@ -83,8 +83,22 @@ interface MessageWithParts {
     parts: MessagePart[];
 }
 declare function resolveDelegatedPlanTaskId(args: Record<string, unknown>, knownPlanTaskIds?: ReadonlySet<string>): string | null;
-export declare function hasReviewedTaskRows(output: string): boolean;
-export declare function parseReviewedTaskIdsFromSetDispatchOutput(output: string): string[];
+/**
+ * Parses structured per-task verdict lines from agent dispatch output.
+ *
+ * Recognized formats:
+ *   [REVIEWED] | task-2.1 | APPROVED | ...
+ *   [TESTED] | task-2.1 | PASS | ...
+ *   [REVIEWED] | 2.1 | APPROVED | ...   (bare task ID without prefix)
+ *
+ * Returns a Map from task ID to verdict string (e.g. "APPROVED", "REJECTED", "PASS", "FAIL").
+ * Only task IDs matching strict task ID format (N.M or N.M.P) are included.
+ * Lines that don't match the pattern are silently ignored.
+ *
+ * @param outputText - Raw text output from the agent dispatch
+ * @returns Map of taskId -> verdict string
+ */
+export declare function parsePerTaskVerdicts(outputText: string): Map<string, string>;
 declare function buildParallelExecutionGuidance(directory: string | undefined, sessionID: string, session: AgentSessionState): Promise<string | null>;
 /**
  * Resolves the correct task ID for evidence recording by chaining:
@@ -109,6 +123,7 @@ declare function resolveEvidenceTaskId(args: Record<string, unknown> | undefined
 export declare const _internals: {
     resolveEvidenceTaskId: typeof resolveEvidenceTaskId;
     resolveDelegatedPlanTaskId: typeof resolveDelegatedPlanTaskId;
+    parsePerTaskVerdicts: typeof parsePerTaskVerdicts;
     buildParallelExecutionGuidance: typeof buildParallelExecutionGuidance;
     loadPlanJsonOnly: typeof loadPlanJsonOnly;
     resetStandardWorktreeIsolationState: typeof resetStandardWorktreeIsolationState;

package/dist/hooks/full-auto-intercept.d.ts

@@ -53,7 +53,7 @@ export declare function injectVerdictIntoMessages(messages: MessageWithParts[],
  * This function encapsulates the critic invocation and event writing flow.
  * The critic response is awaited before writing the event to events.jsonl.
  */
-export declare function dispatchCriticAndWriteEvent(directory: string, architectOutput: string, criticContext: string, criticModel: string, escalationType: 'phase_completion' | 'question', interactionCount: number, deadlockCount: number, oversightAgentName: string, sessionID?: string): Promise<CriticDispatchResult>;
+export declare function dispatchCriticAndWriteEvent(directory: string, architectOutput: string, criticContext: string, criticModel: string, escalationType: 'phase_completion' | 'question', interactionCount: number, deadlockCount: number, oversightAgentName: string, sessionID?: string, maxDispatchRetries?: number, maxConsecutiveDispatchFailures?: number): Promise<CriticDispatchResult>;
 /**
  * Creates the full-auto intercept hook factory.
  *

package/dist/hooks/knowledge-events.d.ts

@@ -144,7 +144,27 @@ export interface SkillStaleBatchEvent {
     retiredCount: number;
     staleCount: number;
 }
-export type KnowledgeEvent = RetrievedEvent | ReceiptEvent | OutcomeEvent | ArchivedEvent | EscalationEvent | SkillStaleBatchEvent;
+/**
+ * A diagnostic tombstone: the architect auto-injection hook skipped injection
+ * for a diagnosable reason (issue #1768). Every silent early-return in
+ * `createKnowledgeInjectorHook` emits one of these so the dead-path cause is
+ * recoverable from `.swarm/knowledge-events.jsonl`. Diagnostic only —
+ * `recomputeCounters` intentionally ignores it (no counter mutation).
+ */
+export interface InjectionSkipEvent {
+    type: 'injection_skip';
+    schema_version?: number;
+    event_id: string;
+    timestamp: string;
+    /** Machine-readable reason tag (e.g. 'headroom_budget', 'no_agent_name'). */
+    reason: string;
+    agent?: string;
+    session_id?: string;
+    phase?: number;
+    /** Structured, redactable detail (char counts, model id, etc.). */
+    detail?: Record<string, unknown>;
+}
+export type KnowledgeEvent = RetrievedEvent | ReceiptEvent | OutcomeEvent | ArchivedEvent | EscalationEvent | SkillStaleBatchEvent | InjectionSkipEvent;
 export type KnowledgeEventType = KnowledgeEvent['type'];
 /**
  * Event shape accepted by {@link appendKnowledgeEvent} / {@link recordKnowledgeEvent}.

package/dist/hooks/knowledge-injector.d.ts

@@ -9,6 +9,8 @@ import { recordKnowledgeShown } from './knowledge-application.js';
 import { buildEscalationBriefing, readRecentEscalations } from './knowledge-escalator.js';
 import { recordKnowledgeEvent } from './knowledge-events.js';
 import type { RankedEntry } from './knowledge-reader.js';
+import { recordLessonsShown } from './knowledge-reader.js';
+import { confirmEntriesPhase } from './knowledge-store.js';
 import type { DirectivePriority, KnowledgeConfig, MessageWithParts } from './knowledge-types.js';
 import { searchKnowledge } from './search-knowledge.js';
 /** Marker that uniquely identifies the delegate directive block in a transcript. */
@@ -97,4 +99,6 @@ export declare const _internals: {
     recordKnowledgeShown: typeof recordKnowledgeShown;
     readRecentEscalations: typeof readRecentEscalations;
     buildEscalationBriefing: typeof buildEscalationBriefing;
+    recordLessonsShown: typeof recordLessonsShown;
+    confirmEntriesPhase: typeof confirmEntriesPhase;
 };

package/dist/hooks/knowledge-reader.d.ts

@@ -35,6 +35,21 @@ export interface RankedEntry extends KnowledgeEntryBase {
     };
 }
 declare function transactShownFile(shownFile: string, mutate: (data: Record<string, string[]>) => Record<string, string[]> | null): Promise<boolean>;
+/**
+ * Records the set of knowledge IDs actually injected during a phase under the
+ * canonical `Phase N` key in `.swarm/.knowledge-shown.json`, so
+ * {@link updateRetrievalOutcome} can later attribute the phase's outcome to
+ * exactly those entries.
+ *
+ * Ownership (issue #1768): the shown-set write lives HERE at the injector layer
+ * (which knows the final rendered set), NOT inside `readMergedKnowledge` (which
+ * only sees the widened pre-rerank pool). Multiple injectors (architect +
+ * delegate) may write the same `Phase N` key within one phase, so the key is
+ * **union-merged** (dedup-safe) rather than overwritten — otherwise the last
+ * writer would clobber earlier id sets and those entries would receive no
+ * outcome attribution.
+ */
+export declare function recordLessonsShown(directory: string, lessonIds: string[], currentPhase: string): Promise<void>;
 export declare function readMergedKnowledge(directory: string, config: KnowledgeConfig, context?: ProjectContext, opts?: {
     skipScopeFilter?: boolean;
 }): Promise<RankedEntry[]>;
@@ -52,5 +67,6 @@ export declare const _internals: {
     scoreDirectiveAgainstContext: typeof scoreDirectiveAgainstContext;
     transactShownFile: typeof transactShownFile;
     recordKnowledgeEvent: typeof recordKnowledgeEvent;
+    recordLessonsShown: typeof recordLessonsShown;
 };
 export {};