opencode-swarm 7.139.0 → 7.139.2

package/dist/hooks/init-orphan-recovery.d.ts

@@ -18,8 +18,9 @@ import * as fs from 'node:fs';
 import { scanDelegationFallbacksForRecovery, scanDelegationsForRecovery } from '../background/pending-delegations.js';
 import { isLocked, listActiveLocks, tryAcquireLock } from '../parallel/file-locks';
 import { removeWorktree } from '../worktree/core';
+import { scanRegisteredWorktreeLiveness } from '../worktree/merge';
 import { scanWorktreeMergeFailuresForRecovery } from './delegation-gate/worktree-merge-status';
-import { scanWorktreeProvisioningOwnersForRecovery } from './delegation-gate/worktree-provisioning-owner';
+import { removeWorktreeProvisioningOwner, scanWorktreeProvisioningOwnersForRecovery } from './delegation-gate/worktree-provisioning-owner';
 type OwnershipTagSessionScan = {
     status: 'ok';
     sessionIds: string[];
@@ -49,6 +50,8 @@ export declare const _internals: {
     scanDelegationFallbacksForRecovery: typeof scanDelegationFallbacksForRecovery;
     scanWorktreeMergeFailuresForRecovery: typeof scanWorktreeMergeFailuresForRecovery;
     scanWorktreeProvisioningOwnersForRecovery: typeof scanWorktreeProvisioningOwnersForRecovery;
+    scanRegisteredWorktreeLiveness: typeof scanRegisteredWorktreeLiveness;
+    removeWorktreeProvisioningOwner: typeof removeWorktreeProvisioningOwner;
 };
 export interface InitOrphanRecoveryResult {
     attempted: boolean;

package/dist/hooks/knowledge-application-gate.d.ts

@@ -4,7 +4,8 @@
  * Two integration points:
  *
  *   1. `experimental.chat.messages.transform` — scans the latest
- *      architect-authored message for `KNOWLEDGE_APPLIED|IGNORED|VIOLATED`
+ *      architect-authored message for
+ *      `KNOWLEDGE_APPLIED|IGNORED|CONTRADICTED|VIOLATED`
  *      markers and records them via `recordAcknowledgmentDeduped`. This
  *      runs BEFORE the architect's next tool call so the toolBefore gate
  *      sees the ack.

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

@@ -1,6 +1,6 @@
 /**
  * Knowledge application tracking — distinguishes shown / acknowledged / applied
- * / ignored / violated outcomes for injected knowledge directives.
+ * / ignored / contradicted / violated outcomes for injected knowledge directives.
  *
  * Writes one JSONL line per outcome to `.swarm/knowledge-application.jsonl`,
  * and updates per-entry retrieval-outcome counters on the source knowledge file.
@@ -13,12 +13,13 @@ export declare const MAX_LEGACY_APPLICATION_LOG_ENTRIES = 5000;
  * Recognised forms (case-insensitive, line-anchored or inline):
  *   KNOWLEDGE_APPLIED: <id>
  *   KNOWLEDGE_IGNORED: <id> reason=<reason>
+ *   KNOWLEDGE_CONTRADICTED: <id> reason=<observable conflict>
  *   KNOWLEDGE_VIOLATED: <id> reason=<reason>
  *   KNOWLEDGE_N_A: <id> reason=<reason>   (delegate contract, Change 1)
  */
 export interface ParsedAcknowledgment {
     id: string;
-    result: 'applied' | 'ignored' | 'violated' | 'n_a';
+    result: 'applied' | 'ignored' | 'contradicted' | 'violated' | 'n_a';
     reason?: string;
 }
 export declare function parseAcknowledgments(text: string): ParsedAcknowledgment[];
@@ -32,7 +33,7 @@ export interface RecordContext {
 }
 /** Record one or more knowledge IDs as "shown" (injected into context). */
 export declare function recordKnowledgeShown(directory: string, ids: string[], ctx: RecordContext): Promise<void>;
-/** Record an explicit acknowledgment outcome (applied / ignored / violated).
+/** Record an explicit acknowledgment outcome (applied / ignored / contradicted / violated).
  *  Per-(sessionId, knowledgeId, result) dedup is enforced by the
  *  caller via swarmState.knowledgeAckDedup; this fn always records when
  *  invoked, so test code can trigger duplicates if needed. The runtime
@@ -57,7 +58,7 @@ export interface ShownNotAppliedQuery {
 }
 /**
  * Returns the subset of `knowledgeIds` that have at least one "shown" record
- * in the audit log without a subsequent "applied"/"ignored"/"violated" record
+ * in the audit log without a subsequent "applied"/"ignored"/"contradicted"/"violated" record
  * in the same task or phase scope.
  */
 export declare function getShownButNotAcknowledged(directory: string, q: ShownNotAppliedQuery): Promise<string[]>;

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

@@ -92,6 +92,10 @@ export declare function defaultExpectedToolsForAgent(agentName: string): string[
  * are stripped on both sides so `mega_coder` matches a bare `coder`.
  */
 export declare function matchesDelegateScope(entry: Pick<RankedEntry, 'applies_to_agents' | 'applies_to_tools'>, role: string, expectedTools: readonly string[]): boolean;
+/** Inserts the knowledge block just before the last user message (recency position). */
+declare function injectKnowledgeMessage(output: {
+    messages?: MessageWithParts[];
+}, text: string): void;
 /**
  * Creates a knowledge injection hook that injects relevant knowledge into the
  * architect's message context at phase start. Supports caching for re-injection
@@ -114,3 +118,15 @@ export declare const _internals: {
     recordLessonsShown: typeof recordLessonsShown;
     confirmEntriesPhase: typeof confirmEntriesPhase;
 };
+/**
+ * Tier-0 test seam (see `.opencode/skills/writing-tests/SKILL.md`). Exposes the
+ * real injection primitive and its sentinel so the
+ * `consolidateSystemMessages` interaction test (issue #1619) exercises the
+ * production splice position and message shape instead of a hand-copied fixture
+ * that could silently drift from this module.
+ */
+export declare const _test_exports: {
+    injectKnowledgeMessage: typeof injectKnowledgeMessage;
+    INJECTION_SENTINEL: string;
+};
+export {};

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

@@ -549,7 +549,7 @@ export interface KnowledgeRetrievalContext {
     planConstraints?: string[];
     mode?: RetrievalMode;
 }
-export type KnowledgeApplicationResult = 'shown' | 'acknowledged' | 'applied' | 'ignored' | 'violated';
+export type KnowledgeApplicationResult = 'shown' | 'acknowledged' | 'applied' | 'ignored' | 'contradicted' | 'violated';
 /** One line of .swarm/knowledge-application.jsonl. */
 export interface KnowledgeApplicationRecord {
     timestamp: string;

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

@@ -31,4 +31,22 @@ type PartsMessage = {
 };
 export type Message = FlatMessage | PartsMessage;
 export declare function consolidateSystemMessages(messages: Message[]): Message[];
+/**
+ * In-place variant of {@link consolidateSystemMessages} for use inside an
+ * `experimental.chat.messages.transform` handler.
+ *
+ * The OpenCode host invokes each plugin hook as `M(input, output)`, **discards
+ * the handler's return value**, and afterwards reads its OWN local message
+ * array (host binary offset ~100,667,665:
+ * `yield* d.trigger("experimental.chat.messages.transform",{},{messages:C})`
+ * followed by `Me.toModelMessagesEffect(C,Z)`). Therefore
+ * `output.messages = consolidateSystemMessages(output.messages)` is a *rebind*
+ * that the host never observes — it silently did nothing in production from the
+ * day it was written until issue #1619. Only mutating the array the host handed
+ * us is observable.
+ *
+ * The consolidated result is computed BEFORE the array is cleared, because
+ * `consolidateSystemMessages` reads the same array it is passed.
+ */
+export declare function consolidateSystemMessagesInPlace(messages: Message[]): void;
 export {};

package/dist/hooks/model-limits.d.ts

@@ -1,19 +1,41 @@
 /**
- * Provider-Aware Model Limit Resolution
+ * Provider-Aware Model Limit Resolution — STATIC FALLBACK ONLY.
  *
- * Resolves context window limits based on the model and provider platform.
- * The same model has different context limits depending on the provider:
- * - Claude Sonnet 4.6: 200k native, 128k on Copilot
- * - GPT-5: 400k native, 128k on Copilot
- * - Copilot caps ALL models at 128k prompt, regardless of native limit
+ * > **The two tables below are a last resort, not the source of truth.**
+ * > The authoritative context window is the live `model.limit.context` the host
+ * > hands to `experimental.chat.system.transform`, resolved through
+ * > `src/config/context-window.ts`. That value is already provider-specific:
+ * > the host's model catalog is keyed `providers[providerID].models[modelID]`,
+ * > and the on-disk catalog shows `github-copilot`'s `claude-sonnet-4.5` and
+ * > `anthropic`'s `claude-sonnet-4-5` carrying different `limit.context`
+ * > values. These tables are consulted only when no live value reached the
+ * > call site (the `experimental.chat.messages.transform` paths on the very
+ * > first turn of a session, before any `system.transform` has run).
+ *
+ * **These tables are known-stale and are deliberately NOT used to cap the live
+ * value.** `PROVIDER_CAPS` claims Copilot caps everything at 128 000; the live
+ * catalog shows Copilot Claude entries at 200 000 (`claude-sonnet-4.5`,
+ * `claude-sonnet-4.6`) and 1 000 000 (`claude-fable-5`), with only `gpt-4.1`
+ * actually at 128 000. Min-capping a correct live value against that would
+ * reintroduce the too-small denominator the live derivation exists to remove.
+ * `NATIVE_MODEL_LIMITS` is stale in the same direction (`claude-sonnet-4` is
+ * listed at 200 000; the catalog reports 216 000).
+ *
+ * Do not "refresh" these tables by hand — that is the maintenance treadmill the
+ * live derivation replaced. They exist so a first-turn `messages.transform`
+ * consumer degrades to a plausible number instead of the flat 128 000 floor.
  */
 /**
  * Native model context limits (in tokens) when used on their native platform.
+ *
+ * Static fallback only — see the module header.
  */
 export declare const NATIVE_MODEL_LIMITS: Record<string, number>;
 /**
  * Provider-specific context caps that override native limits.
- * These are typically lower than native limits (e.g., Copilot caps at 128k).
+ *
+ * Static fallback only, and known-stale — see the module header. This is NOT
+ * applied as a ceiling over the live `model.limit.context`.
  */
 export declare const PROVIDER_CAPS: Record<string, number>;
 /**
@@ -51,46 +73,82 @@ export declare function extractModelInfo(messages: MessageWithParts[]): {
     modelID?: string;
     providerID?: string;
 };
+/**
+ * Extracts the sessionID from a `experimental.chat.messages.transform` message
+ * array, scanning newest-first.
+ *
+ * The messages hooks receive no `input.sessionID` (the plugin type declares
+ * `input: {}`), but every message's `info` carries one. This is the key used to
+ * look up the live `model.limit.context` that the `system.transform` hook
+ * recorded for the session — see `getLiveContextWindow` in `src/state.ts`.
+ *
+ * @returns the sessionID, or `undefined` when no message carries one.
+ */
+export declare function extractSessionId(messages: MessageWithParts[] | undefined): string | undefined;
+/**
+ * Static-table lookup used as `fallbackLookup` for
+ * {@link resolveContextWindow}. Preserves the historical precedence of
+ * the two tables relative to each other (provider cap first, then a
+ * longest-prefix native match), and is reachable only when no live
+ * `model.limit.context` was available.
+ */
+export declare function lookupStaticModelLimit(modelID?: string, providerID?: string): number | undefined;
 /**
  * Resolves the context limit for a given model/provider combination.
  *
- * Resolution order (first match wins):
- * 1. Check configOverrides["provider/model"] (e.g., "copilot/claude-sonnet-4-6": 200000)
- * 2. Check configOverrides[modelID] (e.g., "claude-sonnet-4-6": 200000)
- * 3. Check PROVIDER_CAPS[providerID] (e.g., copilot → 128000)
- * 4. Check NATIVE_MODEL_LIMITS with prefix matching (e.g., "claude-sonnet-4" matches "claude-sonnet-4-6-20260301")
- * 5. Check configOverrides.default
- * 6. Fall back to 128000
+ * Thin adapter over the single derivation in `src/config/context-window.ts` —
+ * this function exists so the `experimental.chat.messages.transform` consumers
+ * (`context-budget.ts`, `knowledge-injector.ts`, `tools/context-status.ts`)
+ * keep their existing `(modelID, providerID, overrides)` call shape. All
+ * ordering logic lives in the shared resolver; see its module header.
+ *
+ * Resolution order (first usable value wins):
+ * 1. `configOverrides["<providerID>/<modelID>"]`
+ * 2. `configOverrides["<modelID>"]`
+ * 3. `configOverrides.default`
+ * 4. `liveContextLimit` — the host's live `model.limit.context` for this session
+ * 5. `PROVIDER_CAPS[providerID]`, else a longest-prefix `NATIVE_MODEL_LIMITS`
+ *    match (both known-stale; see the module header)
+ * 6. `DEFAULT_MODEL_CONTEXT_TOKENS` (128000)
+ *
+ * Two ordering changes vs. the pre-#1619 implementation, both deliberate:
+ * - `configOverrides.default` moved from below the static tables to above
+ *   them. An explicitly authored user value losing to a hardcoded table was a
+ *   defect; it is now consistent with the compound and model-only keys, which
+ *   already outranked the tables.
+ * - The live `model.limit.context` was inserted above both tables, which is
+ *   the entire point of this change.
+ *
+ * Any value that is not a finite number ≥ 1000 is skipped rather than used, so
+ * a malformed override or a catalog entry with `limit.context: 0` can never
+ * produce a `NaN` / `Infinity` percentage.
  *
  * @param modelID - The model identifier (e.g., "claude-sonnet-4-6", "gpt-5")
- * @param providerID - The provider identifier (e.g., "copilot", "anthropic")
- * @param configOverrides - User configuration overrides
+ * @param providerID - The provider identifier (e.g., "github-copilot", "anthropic")
+ * @param configOverrides - User configuration overrides (`context_budget.model_limits`)
+ * @param liveContextLimit - The live `model.limit.context` recorded for this
+ *   session by the `system.transform` hook, when one has been seen
  * @returns The resolved context limit in tokens
  *
  * @example
- * // Provider cap (copilot)
- * resolveModelLimit("claude-sonnet-4-6", "copilot", {})
- * // Returns: 128000
- *
- * @example
- * // Native limit (anthropic)
- * resolveModelLimit("claude-sonnet-4-6", "anthropic", {})
+ * // Live value wins over the stale static tables
+ * resolveModelLimit("claude-sonnet-4-6", "github-copilot", {}, 200000)
  * // Returns: 200000
  *
  * @example
- * // Override beats cap
- * resolveModelLimit("gpt-5", "copilot", { "copilot/gpt-5": 200000 })
- * // Returns: 200000
+ * // Explicit user override beats the live value
+ * resolveModelLimit("gpt-5", "github-copilot", { "github-copilot/gpt-5": 60000 }, 400000)
+ * // Returns: 60000
  *
  * @example
- * // Prefix match for model variants
+ * // No live value: falls back to the static table (prefix match)
  * resolveModelLimit("claude-sonnet-4-6-20260301", "anthropic", {})
  * // Returns: 200000
  *
  * @example
- * // Full fallback
- * resolveModelLimit(undefined, undefined, {})
+ * // Malformed live value is ignored, not divided by
+ * resolveModelLimit(undefined, undefined, {}, 0)
  * // Returns: 128000
  */
-export declare function resolveModelLimit(modelID?: string, providerID?: string, configOverrides?: Record<string, number>): number;
+export declare function resolveModelLimit(modelID?: string, providerID?: string, configOverrides?: Record<string, number>, liveContextLimit?: unknown): number;
 export {};

package/dist/hooks/pr-workflow-gate.d.ts

@@ -283,6 +283,13 @@ export interface PrWorkflowGateState {
     /** Canonical ordered semantic ledger frozen by the first micro dispatch. */
     prReviewTriggerLedger?: PrReviewInlineTriggerRow[];
     prReviewTriggerEvalPath?: string;
+    /**
+     * The run_id bound to the trigger-evaluation receipt at first consumption.
+     * Mirrors `prReviewArtifactRunId`: once set, a subsequent receipt under a
+     * different run_id is rejected, and it must agree with the findings artifact
+     * run_id (both live under `.swarm/pr-review/<run_id>/`). Closes issue #2124.
+     */
+    prReviewTriggerEvalRunId?: string;
     prReviewValidationBatches?: PrReviewValidationBatchRecord[];
     /** Keyed by validation batch id. See `PrReviewBatchCoherenceRecord`. */
     prReviewBatchCoherence?: Record<string, PrReviewBatchCoherenceRecord>;
@@ -465,7 +472,7 @@ export declare function recordPrFeedbackGateBatch(directory: string, sessionID:
 export declare function assertPrFeedbackGatePhaseSettled(directory: string, sessionID: string, phase: PrFeedbackGatePhase): Promise<PrWorkflowGateState>;
 /** Require every ordered feedback gate on one unchanged revision. */
 export declare function assertPrFeedbackReadyToPublish(directory: string, sessionID: string): Promise<PrWorkflowGateState>;
-export declare function markPrReviewTriggerEvaluationComplete(directory: string, sessionID: string, artifactPath: string): Promise<PrWorkflowGateState>;
+export declare function markPrReviewTriggerEvaluationComplete(directory: string, sessionID: string, runId: string, artifactPath: string): Promise<PrWorkflowGateState>;
 /** Freeze one exact inline trigger ledger across every micro dispatch. */
 export declare function bindPrReviewTriggerLedger(directory: string, sessionID: string, input: unknown): Promise<PrWorkflowGateState>;
 export declare function assertPrReviewArtifactBoundary(directory: string, sessionID: string, runId: string, boundary: PrReviewArtifactBoundary, findingIds: string[]): Promise<PrWorkflowGateState>;