opencode-swarm 7.152.0 → 7.153.0

package/dist/learning/provenance.d.ts

@@ -17,6 +17,7 @@
  * supply `producedAt` — callers that need determinism pass it explicitly.
  */
 import { z } from 'zod';
+import { type WriteAuthorityOrigin } from '../security/write-authority.js';
 /**
  * Hard cap on entries retained per reference class. Sorting happens before the
  * cap so truncation is deterministic rather than insertion-order dependent.
@@ -41,6 +42,12 @@ export declare const LearningProvenanceV1Schema: z.ZodObject<{
     writeOrigin: z.ZodObject<{
         sessionId: z.ZodOptional<z.ZodString>;
         agentRole: z.ZodOptional<z.ZodString>;
+        authority: z.ZodOptional<z.ZodEnum<{
+            critic_approved: "critic_approved";
+            autonomous: "autonomous";
+            optimizer_proposed: "optimizer_proposed";
+            human_approved: "human_approved";
+        }>>;
         producedAt: z.ZodISODateTime;
     }, z.core.$strict>;
 }, z.core.$strict>;
@@ -56,6 +63,7 @@ export interface LearningProvenanceV1 {
     writeOrigin: {
         sessionId?: string;
         agentRole?: string;
+        authority?: WriteAuthorityOrigin;
         producedAt: string;
     };
 }
@@ -72,6 +80,7 @@ export interface LearningProvenanceInput {
 export interface LearningWriteOriginInput {
     sessionId?: string;
     agentRole?: string;
+    authority?: WriteAuthorityOrigin;
     producedAt?: string;
 }
 /**

package/dist/sandbox/capability-probe.d.ts

@@ -9,6 +9,8 @@
  * Each probe is bounded to 2 seconds via AbortController to satisfy
  * Invariant 1 (plugin init is fast, bounded, fail-open).
  */
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
 /** Possible sandbox status values. */
 export type SandboxStatus = 'enabled' | 'disabled' | 'unsupported';
 /**
@@ -20,6 +22,7 @@ export type SandboxStatus = 'enabled' | 'disabled' | 'unsupported';
  *   (issue #1778 H2).
  */
 export type SandboxStrength = 'strong' | 'advisory';
+export type SandboxDimensionStrength = 'real' | 'weak' | 'none';
 /** Result of a sandbox capability probe. */
 export interface SandboxCapability {
     /** Whether the sandbox mechanism is available. */
@@ -36,6 +39,37 @@ export interface SandboxCapability {
     /** Error message from the probe, if any. */
     error?: string;
 }
+export interface SandboxCapabilityV1 extends SandboxCapability {
+    v: 1;
+    filesystem: SandboxDimensionStrength;
+    network: SandboxDimensionStrength;
+    process: SandboxDimensionStrength;
+    effective: SandboxDimensionStrength;
+    reasons: string[];
+    identity: string;
+}
+export interface SandboxRequirements {
+    mode?: 'advisory' | 'required';
+    require_filesystem?: boolean;
+    require_network?: boolean;
+    require_process?: boolean;
+    network_mode?: 'off' | 'on';
+    network_allowlist?: readonly string[];
+    writable_roots?: readonly string[];
+}
+export declare function assessSandboxRequirements(capability: SandboxCapabilityV1, requirements: SandboxRequirements | undefined): {
+    satisfied: boolean;
+    missing: string[];
+};
+interface BehavioralEvidence {
+    filesystem: SandboxDimensionStrength;
+    network: SandboxDimensionStrength;
+    process: SandboxDimensionStrength;
+    reasons: string[];
+}
+declare function currentProbeSourceIdentity(platform: 'linux' | 'darwin' | 'win32'): string;
+declare function resolveWindowsCommandProcessorBinary(): string;
+declare function detectBehavioralEvidence(capability: SandboxCapability): BehavioralEvidence;
 /** Reset the session-lifetime capability cache. Test-only. */
 export declare function _resetCapabilityCache(): void;
 /**
@@ -56,6 +90,11 @@ declare function withProbeTimeout(cmd: string, args: string[], ms: number): Prom
  */
 export declare const _internals: {
     withProbeTimeout: typeof withProbeTimeout;
+    spawnSync: typeof spawnSync;
+    detectBehavioralEvidence: typeof detectBehavioralEvidence;
+    resolveWindowsCommandProcessorBinary: typeof resolveWindowsCommandProcessorBinary;
+    currentProbeSourceIdentity: typeof currentProbeSourceIdentity;
+    removeProbeTempRoot: typeof fs.rmSync;
 };
 /**
  * Detects the availability of OS-native sandbox mechanisms.
@@ -86,6 +125,6 @@ export declare class SandboxCapabilityProbe {
      *
      * @returns A promise that resolves to the sandbox capability result.
      */
-    detect(): Promise<SandboxCapability>;
+    detect(): Promise<SandboxCapabilityV1>;
 }
 export {};

package/dist/sandbox/executor.d.ts

@@ -4,6 +4,7 @@
  * Provides a unified interface for sandboxed shell command execution across
  * Linux (Bubblewrap), macOS (sandbox-exec), and Windows (restricted token/Low Integrity).
  */
+import { type SandboxCapabilityV1, type SandboxRequirements } from './capability-probe';
 /**
  * Error thrown when sandbox operations fail.
  */
@@ -11,6 +12,7 @@ export declare class SandboxError extends Error {
     readonly code: string;
     constructor(message: string, code: string);
 }
+export declare function normalizeSandboxMechanism(mechanism: string): string;
 /**
  * Validate that a string is a valid POSIX environment variable name.
  * POSIX env var names: [a-zA-Z_][a-zA-Z0-9_]*
@@ -43,13 +45,33 @@ export interface SandboxExecutor {
      * @returns The wrapped command string with sandbox prefix
      * @throws SandboxError if sandbox cannot wrap the command
      */
-    wrapCommand(command: string, scopePaths: string[], tempDir?: string, envOverrides?: Record<string, string | null>): string;
+    wrapCommand(command: string, scopePaths: string[], tempDir?: string, envOverrides?: Record<string, string | null>, policy?: SandboxPolicyOptions): string;
     /**
      * Get the environment variable overrides for this sandbox.
      * Returns a record of env vars to set/unset.
      */
     getEnvOverrides(): Record<string, string | null>;
 }
+export interface SandboxPolicyOptions {
+    network_mode?: 'off' | 'on';
+    network_allowlist?: readonly string[];
+    writable_roots?: readonly string[];
+}
+declare function detectSandboxCapability(): Promise<SandboxCapabilityV1>;
+export declare const _internals: {
+    detectSandboxCapability: typeof detectSandboxCapability;
+};
+export interface SandboxEnforcementAssessment {
+    capability: SandboxCapabilityV1;
+    requirements: Required<SandboxRequirements>;
+    policy: Required<SandboxPolicyOptions>;
+    satisfied: boolean;
+    missing: string[];
+    supported: boolean;
+    unsupported: string[];
+    cacheKey: string;
+}
+export declare function assessSandboxEnforcement(requirements: SandboxRequirements | undefined): Promise<SandboxEnforcementAssessment>;
 /**
  * Get the platform-appropriate sandbox executor.
  *
@@ -80,3 +102,6 @@ export declare function _getMacOSSandboxPolicyForTest(): boolean;
  * @internal
  */
 export declare function _resetExecutorCache(): void;
+/** @internal test seam */
+export declare function _resetSandboxAssessmentCache(): void;
+export {};

package/dist/sandbox/linux/bubblewrap-executor.d.ts

@@ -75,7 +75,9 @@ export declare class BubblewrapSandboxExecutor implements SandboxExecutor {
      * @returns A bwrap-wrapped command string ready for shell execution,
      *          or the raw command string when the sandbox is unavailable (passthrough mode)
      */
-    wrapCommand(command: string, scopePaths: string[], tempDir?: string, envOverrides?: Record<string, string | null>): string;
+    wrapCommand(command: string, scopePaths: string[], tempDir?: string, envOverrides?: Record<string, string | null>, policy?: {
+        network_mode?: 'off' | 'on';
+    }): string;
     /**
      * Return environment variable overrides required for the bubblewrap sandbox.
      *

package/dist/sandbox/macos/sandbox-exec-executor.d.ts

@@ -104,7 +104,9 @@ export declare class MacOSSandboxExecutor implements SandboxExecutor {
      * @returns A sandbox-exec wrapped command string ready for shell execution,
      *          or the raw command string when the sandbox is unavailable (passthrough mode)
      */
-    wrapCommand(command: string, scopePaths: string[], tempDir?: string, envOverrides?: Record<string, string | null>): string;
+    wrapCommand(command: string, scopePaths: string[], tempDir?: string, envOverrides?: Record<string, string | null>, _policy?: {
+        network_mode?: 'off' | 'on';
+    }): string;
     /**
      * Return environment variable overrides required for the macOS sandbox.
      *

package/dist/sandbox/skip-state.d.ts

@@ -0,0 +1,24 @@
+export interface SandboxWrapOutcome {
+    sessionID: string;
+    callID: string;
+    originalCommandHash: number;
+    finalCommandHash: number;
+    wrapped: boolean;
+    capabilityIdentity: string;
+    assessmentCacheKey: string;
+    reason: string;
+    originalCommand: string;
+    executorMechanism: string;
+    capabilityMechanism: string;
+}
+export declare function recordSandboxWrapOutcome(outcome: SandboxWrapOutcome): void;
+export declare function readSandboxWrapOutcome(sessionID: string, callID: string): SandboxWrapOutcome | null;
+export declare function clearSandboxWrapOutcome(sessionID: string, callID: string): void;
+export declare function getSandboxSkipSummary(sessionID?: string): {
+    count: number;
+    reasons: readonly string[];
+};
+/** @internal test seam */
+export declare function _resetSandboxWrapOutcomeState(): void;
+/** @internal test seam */
+export declare function _sandboxWrapOutcomeStateSize(): number;

package/dist/sandbox/win32/native-sandbox-executor.d.ts

@@ -37,7 +37,11 @@ export declare class NativeWindowsSandboxExecutor implements SandboxExecutor {
      *
      * When the runner is unavailable, falls back to the PowerShell wrapper.
      */
-    wrapCommand(command: string, scopePaths: string[], tempDir?: string, envOverrides?: Record<string, string | null>): string;
+    wrapCommand(command: string, scopePaths: string[], tempDir?: string, envOverrides?: Record<string, string | null>, policy?: {
+        network_mode?: 'off' | 'on';
+        network_allowlist?: readonly string[];
+        writable_roots?: readonly string[];
+    }): string;
     private _wrapWithRunner;
     getEnvOverrides(): Record<string, string | null>;
     /**

package/dist/security/command-classifier.d.ts

@@ -0,0 +1,22 @@
+export type CommandRiskCategory = 'catastrophic' | 'destructive' | 'unknown' | 'escalate' | 'safe';
+export interface CommandSegmentClassificationV1 {
+    segment: string;
+    category: CommandRiskCategory;
+    reason: string;
+    ruleId?: string;
+}
+export interface CommandClassificationV1 {
+    v: 1;
+    originalDigest: string;
+    aggregate: CommandRiskCategory;
+    ambiguous: boolean;
+    segments: readonly CommandSegmentClassificationV1[];
+}
+export interface SharedClassifierGuardrailBlockV1 {
+    ruleId: string;
+    category: Extract<CommandRiskCategory, 'catastrophic' | 'destructive'>;
+    destructiveCategory: string;
+    message: string;
+}
+export declare function getSharedClassifierGuardrailBlock(classification: Readonly<CommandClassificationV1>): Readonly<SharedClassifierGuardrailBlockV1> | null;
+export declare function classifyCommand(original: string): Readonly<CommandClassificationV1>;

package/dist/security/protected-input-integrity.d.ts

@@ -0,0 +1,19 @@
+export interface ProtectedManifestV1 {
+    v: 1;
+    root: string;
+    digest: string;
+    entries: readonly string[];
+}
+/** Snapshot a protected regular-file tree; ambiguity and budget exhaustion fail closed. */
+export declare function snapshotProtectedTree(root: string): Promise<ProtectedManifestV1>;
+export declare function verifyProtectedTree(before: ProtectedManifestV1): Promise<void>;
+/** Mandatory transaction wrapper for governed evaluators. Verification always runs. */
+export declare function withProtectedInputIntegrity<T>(root: string, operation: () => Promise<T>): Promise<T>;
+export interface ProtectedSetManifestV1 {
+    v: 1;
+    roots: readonly string[];
+    states: readonly (ProtectedManifestV1 | 'missing')[];
+}
+export declare function snapshotProtectedSet(roots: readonly string[]): Promise<ProtectedSetManifestV1>;
+export declare function verifyProtectedSet(before: ProtectedSetManifestV1): Promise<void>;
+export declare function withProtectedSetIntegrity<T>(roots: readonly string[], operation: () => Promise<T>): Promise<T>;

package/dist/security/protected-path-policy.d.ts

@@ -0,0 +1,9 @@
+export interface ProtectedPathPolicyOptions {
+    includeDefaults?: boolean;
+    additional?: readonly string[];
+}
+export declare const DEFAULT_PROTECTED_PATH_PREFIXES: readonly [".github/workflows", ".github/CODEOWNERS", "src/sandbox", "src/hooks/guardrails", "src/security", "src/evaluation", "docs/releases", "tests/fixtures/evaluation"];
+export declare function normalizeProtectedPath(value: string): string;
+/** Central lexical policy; canonical containment remains caller-owned. */
+export declare function isPolicyProtectedPath(filePath: string, options?: ProtectedPathPolicyOptions): boolean;
+export declare function protectedRoots(projectRoot: string, additional?: readonly string[]): string[];

package/dist/security/write-authority.d.ts

@@ -0,0 +1,46 @@
+export type WriteAuthorityOrigin = 'autonomous' | 'optimizer_proposed' | 'critic_approved' | 'human_approved';
+export type WriteApprovalAction = 'skill_improve';
+export interface WriteApprovalRequest {
+    targetSessionId: string;
+    action: WriteApprovalAction;
+    candidateId: string;
+    candidateContentHash: string;
+    allowedPathDigest?: string;
+    generation?: number;
+}
+export interface WriteApprovalFactV1 extends WriteApprovalRequest {
+    v: 1;
+    id: string;
+    issuingSessionId: string;
+    issuedByCommand: 'approve-write';
+    issuedAt: string;
+    expiresAt: string;
+}
+export interface WriteAuthorityContext {
+    origin: WriteAuthorityOrigin;
+    fact?: WriteApprovalFactV1;
+}
+export declare function computeWriteApprovalHash(input: Record<string, unknown>): string;
+export declare function getCurrentWriteAuthority(): WriteAuthorityContext;
+export declare function withWriteAuthority<T>(context: WriteAuthorityContext, fn: () => Promise<T>): Promise<T>;
+export declare function buildHumanApprovedWriteAuthority(fact: WriteApprovalFactV1): WriteAuthorityContext;
+export declare function currentWriteAuthoritySatisfies(request: WriteApprovalRequest): boolean;
+export declare function formatApproveWriteCommand(request: WriteApprovalRequest): string;
+export declare function findWriteApprovalFact(args: {
+    directory: string;
+    request: WriteApprovalRequest;
+    now?: Date;
+}): Promise<WriteApprovalFactV1 | null>;
+export declare function issueWriteApprovalFact(args: {
+    directory: string;
+    request: WriteApprovalRequest;
+    issuingSessionId: string;
+    now?: Date;
+    ttlMs?: number;
+}): Promise<WriteApprovalFactV1>;
+export declare function consumeWriteApprovalFact(args: {
+    directory: string;
+    request: WriteApprovalRequest;
+    consumerSessionId: string;
+    now?: Date;
+}): Promise<WriteApprovalFactV1 | null>;

package/dist/services/diagnose-service.d.ts

@@ -1,6 +1,6 @@
 import { getExecutor } from '../sandbox/executor.js';
 export declare const _internals: {
-    detectSandboxCapability: () => Promise<import("../sandbox/capability-probe.js").SandboxCapability>;
+    detectSandboxCapability: () => Promise<import("../sandbox/capability-probe.js").SandboxCapabilityV1>;
     getSandboxExecutor: typeof getExecutor;
 };
 /**

package/dist/services/skill-generator.d.ts

@@ -100,6 +100,7 @@ export interface GenerateRequest {
     evaluate?: boolean;
     minConfidence?: number;
     minConfirmations?: number;
+    preview?: boolean;
 }
 export interface GenerateResult {
     written: Array<{
@@ -110,6 +111,7 @@ export interface GenerateResult {
         missingSourceKnowledgeIds?: string[];
         preserved: boolean;
         evaluation?: SkillEvaluationResult;
+        content?: string;
     }>;
     skipped: Array<{
         slug: string;

package/dist/services/skill-improver.d.ts

@@ -19,6 +19,7 @@
 import type { EnrichmentQuotaOptions } from '../hooks/knowledge-curator.js';
 import type { KnowledgeEntryBase } from '../hooks/knowledge-types.js';
 import { type SkillImproverLLMDelegate } from '../hooks/skill-improver-llm-factory.js';
+import { type WriteApprovalRequest } from '../security/write-authority.js';
 import { type AutoApplyResult, regenerateSkill } from './skill-generator.js';
 import { type QuotaWindow } from './skill-improver-quota.js';
 export interface SkillImproverConfigInput {
@@ -56,10 +57,20 @@ export interface SkillImproveRequest {
     evaluateDrafts?: boolean;
     /** Consolidation callers stage proposals only and must never auto-apply. */
     allowAutoApply?: boolean;
+    /** Exact approval-phase proposal body returned by a prior challenge. */
+    approvedCandidateContent?: string;
 }
 export interface SkillImproveResult {
     ran: boolean;
     reason?: string;
+    approvalRequired?: {
+        request?: WriteApprovalRequest;
+        command?: string;
+        candidateContent?: string;
+        candidateContentChars?: number;
+        candidateContentTokenEstimate?: number;
+        allowedPaths?: string[];
+    };
     proposalPath?: string;
     source?: 'llm' | 'deterministic_fallback';
     quota: {
@@ -100,6 +111,59 @@ export interface SkillImproveResult {
     /** #1234 Part 3D: critic-gated auto-apply of proposals in full-auto mode. */
     autoApply?: AutoApplyResult;
 }
+export declare const SKILL_IMPROVER_APPROVAL_CANDIDATE_ID = "skill_improve_request";
+export declare const MAX_APPROVED_CANDIDATE_CONTENT_CHARS = 64000;
+interface SkillImproverDraftWrite {
+    slug: string;
+    path: string;
+    content: string;
+    sourceKnowledgeIds: string[];
+    missingSourceKnowledgeIds?: string[];
+}
+interface SkillImproverDraftSourceStampTarget {
+    knowledgePath: string;
+    ids: string[];
+    slug: string;
+    draftGeneratedSkillPath: string;
+    updatedAt: string;
+}
+export declare function buildSkillImproverApprovalRequest(input: {
+    sessionId?: string;
+    candidateContent: string;
+    allowedPaths: string[];
+    candidateId?: string;
+    generation?: number;
+}): WriteApprovalRequest | null;
+export interface PreparedSkillImproverApprovalCandidate {
+    directory: string;
+    sessionId: string;
+    now: Date;
+    source: 'llm' | 'deterministic_fallback';
+    model?: string;
+    proposalPath: string;
+    proposalContent: string;
+    allowedPaths: string[];
+    candidateContent: string;
+    draftWrites: SkillImproverDraftWrite[];
+    draftSourceStamps: SkillImproverDraftSourceStampTarget[];
+    request: WriteApprovalRequest;
+    quota: {
+        date: string;
+        calls_used: number;
+        max_calls: number;
+    };
+    quotaWindow: QuotaWindow;
+    maxCalls: number;
+    maxCallsPerDay: number;
+    released: boolean;
+}
+type SkillImproverApprovalPreparation = {
+    kind: 'result';
+    result: SkillImproveResult;
+} | {
+    kind: 'prepared';
+    prepared: PreparedSkillImproverApprovalCandidate;
+};
 interface InventorySnapshot {
     knowledge: {
         swarm: number;
@@ -152,6 +216,10 @@ export interface StaleSkillReconciliationResult {
 export declare function reconcileStaleActiveSkills(directory: string, options?: {
     dryRun?: boolean;
 }): Promise<StaleSkillReconciliationResult>;
+export declare function prepareSkillImproverApprovalCandidate(req: SkillImproveRequest): Promise<SkillImproverApprovalPreparation>;
+export declare function prepareApprovedSkillImproverCandidateWrite(req: SkillImproveRequest): Promise<SkillImproverApprovalPreparation>;
+export declare function releasePreparedSkillImproverApprovalCandidate(prepared: PreparedSkillImproverApprovalCandidate): Promise<SkillImproveResult['quota']>;
+export declare function writeApprovedSkillImproverCandidate(prepared: PreparedSkillImproverApprovalCandidate): Promise<SkillImproveResult>;
 export declare function runSkillImprover(req: SkillImproveRequest): Promise<SkillImproveResult>;
 export declare const _internals: {
     runSkillImprover: typeof runSkillImprover;
@@ -159,6 +227,7 @@ export declare const _internals: {
     buildLLMProposalFrame: typeof buildLLMProposalFrame;
     buildSystemPrompt: typeof buildSystemPrompt;
     buildUserPrompt: typeof buildUserPrompt;
+    buildSkillImproverApprovalRequest: typeof buildSkillImproverApprovalRequest;
     gatherInventory: typeof gatherInventory;
     reconcileStaleActiveSkills: typeof reconcileStaleActiveSkills;
     regenerateSkill: typeof regenerateSkill;

package/dist/tools/dispatch-lanes.d.ts

@@ -203,8 +203,30 @@ export interface CollectLaneResultsResult {
      * or any lane's state.
      */
     pending_liveness?: PrWorkflowPendingLaneLiveness[];
+    /**
+     * Issue #2381: identities of every lane that had NOT settled when this
+     * collection returned. Present whenever any lane is unsettled, INDEPENDENT of
+     * `include_pending` — a caller must never have to opt in to learn that work is
+     * still outstanding, and a wait budget expiring is not evidence the work died.
+     *
+     * Purely additive: `lane_results` filtering and every aggregate counter are
+     * unchanged, so existing consumers are unaffected.
+     */
+    pending_lanes?: CollectPendingLaneIdentity[];
     errors?: string[];
 }
+/**
+ * Issue #2381: minimal, stable identity of an unsettled lane. `output_ref` is
+ * carried when the record already has one (for example an `ingesting` lane whose
+ * artifact was written before settlement) so a caller can still recover partial
+ * output via `retrieve_lane_output` without a second collection.
+ */
+export interface CollectPendingLaneIdentity {
+    batch_id: string;
+    lane_id: string;
+    status: string;
+    output_ref?: string;
+}
 export interface SessionOps {
     create(args: {
         body?: {
@@ -341,6 +363,8 @@ export declare const _test_exports: {
     nextCollectPollInterval: typeof nextCollectPollInterval;
     promptHash: typeof promptHash;
     reserveCollectionLaneCallBudgets: typeof reserveCollectionLaneCallBudgets;
+    assembleCollectionDiagnostics: typeof assembleCollectionDiagnostics;
+    addLaneDiagnostic: typeof addLaneDiagnostic;
     isRetryableSessionCreateFailure: typeof isRetryableSessionCreateFailure;
     DispatchLanesArgsSchema: z.ZodObject<{
         lanes: z.ZodArray<z.ZodObject<{
@@ -451,6 +475,29 @@ export declare function executeDispatchLanes(args: unknown, directory: string, c
 export declare function executeDispatchLanesAsync(args: unknown, directory: string, context?: DispatchLanesExecutionContext): Promise<DispatchLanesAsyncResult>;
 export declare function executeCollectLaneResults(args: unknown, directory: string, context?: Pick<DispatchLanesExecutionContext, 'sessionID'>): Promise<CollectLaneResultsResult>;
 declare function isRetryableSessionCreateFailure(error: unknown): boolean;
+/**
+ * Issue #2381 (PR review follow-up): lane-keyed collection diagnostics.
+ *
+ * These were message-keyed `Set<string>`s, which forced clearing to match on the
+ * quoted lane label inside the message. Because entries embed host-derived error
+ * text, one lane's error could literally contain another lane's quoted id and
+ * clear it — a missing diagnostic, never a wrong lane state, but a real residue.
+ * Keying by lane removes the class outright: clearing is an exact `delete`, and
+ * no message content can ever influence another lane's entries.
+ */
+type LaneDiagnostics = Map<string, Set<string>>;
+/**
+ * Assemble `result.errors` from the three diagnostic channels.
+ *
+ * Extracted as a pure function so the starvation invariant is testable without
+ * having to drive the poll loop into a real timeout flood: each channel is
+ * bounded INDEPENDENTLY, so no channel can crowd out another no matter how one
+ * of them behaves. The lane-keyed channels lead because they carry the per-lane
+ * cause an operator acts on; `hostTimeouts` is the coarser "a host call ran out
+ * of budget" signal and takes its own slice.
+ */
+declare function assembleCollectionDiagnostics(hostTimeouts: ReadonlySet<string>, settleFailureLogs: LaneDiagnostics, collectionResourceFailures: LaneDiagnostics): string[];
+declare function addLaneDiagnostic(diagnostics: LaneDiagnostics, laneLabel: string, message: string): void;
 declare function consumePrReviewReceiptAppendFailureLog(loggedFailures: Set<string>, parentSessionId: string, correlationId: string): boolean;
 /**
  * Issue #2349: a terminal error read off the last assistant message of a lane

package/dist/tools/repo-graph/query.d.ts

@@ -1,5 +1,5 @@
 import type { FreshnessProbe } from './freshness';
-import type { BlastRadiusResult, CallerReference, ContextPackResult, DeadExportsResult, FileOntology, FileReference, GraphHealthResult, GraphNode, LocalizationBlock, PackageBoundarySummary, RepoGraph, SymbolReference } from './types';
+import type { BlastRadiusResult, CallerReference, ContextPackResult, ContextPackSourceMode, DeadExportsResult, FileOntology, FileReference, GraphHealthResult, GraphNode, LocalizationBlock, PackageBoundarySummary, RepoGraph, SymbolReference } from './types';
 export declare function getGraphNode(graph: RepoGraph, input: string): GraphNode | undefined;
 export declare function resetQueryCache(): void;
 /**
@@ -49,6 +49,7 @@ export declare function getContextPack(graph: RepoGraph, file: string, symbol: s
     maxDepth?: number;
     maxTokens?: number;
     includeSource?: boolean;
+    sourceMode?: ContextPackSourceMode;
     directory?: string;
 }): ContextPackResult;
 export declare function getPackageBoundaries(graph: RepoGraph, topN?: number): PackageBoundarySummary[];

package/dist/tools/repo-graph/types.d.ts

@@ -286,6 +286,64 @@ export interface ContextPackSpan {
     text?: string;
     note?: string;
 }
+/**
+ * Source-text extraction mode for source-bearing context packs (issue #1533).
+ * `include_source` remains the sole gate; `source_mode` only refines what is
+ * extracted once source was requested.
+ *
+ * - `mixed` (default): body text for near spans (span mode 'full'), signature
+ *   text for periphery spans (span mode 'signature').
+ * - `body`: body text for every span with an export range.
+ * - `signature`: signature text for every span with an export range.
+ */
+export type ContextPackSourceMode = 'signature' | 'body' | 'mixed';
+/**
+ * A bounded source snippet with provenance (issue #1533). Emitted one per
+ * returned span that actually had text extracted; internal-symbol fallback
+ * spans produce no snippet.
+ *
+ * `mode` describes the returned text, independent of the owning span's
+ * traversal mode: 'full' = whole range text; 'signature' = signature-only
+ * extraction; 'summary' = body text line-capped at 80 lines.
+ *
+ * `hash` is the sha256 hex of the returned `text` — a content fingerprint.
+ * It is stable for a given source mode and file content; summary-mode hashes
+ * are cap-dependent by design because the text itself is truncated.
+ *
+ * `confidence` is a deterministic resolution-quality score in [0, 1]:
+ * 1.0 = the exact requested target symbol, 0.8 = a resolved neighbor with
+ * extracted text. Spans whose read failed or which lack an export range
+ * produce no snippet at all (their state surfaces via span.note, coverage,
+ * and warnings). It is NOT language grammar quality; issue #1532 (KG-11
+ * SymbolEdge v2) will replace this derivation with real edge confidence.
+ */
+export interface ContextPackSnippet {
+    file: string;
+    symbol: string;
+    startLine: number;
+    endLine: number;
+    mode: 'full' | 'signature' | 'summary';
+    text: string;
+    hash: string;
+    confidence: number;
+}
+/**
+ * Coverage accounting for a context pack (issue #1533).
+ *
+ * `unresolvedEdges` and `lowConfidenceEdges` count distinct destination
+ * SYMBOLS (keyed `file\0symbol`, collected at BFS first discovery), not edge
+ * instances — duplicate edges toward the same unresolved symbol count once.
+ * `lowConfidenceEdges` uses exactly the same predicate as the internal-symbol
+ * span fallback (destination file present, no own-property export range for
+ * the symbol), so coverage and spans can never disagree.
+ */
+export interface ContextPackCoverage {
+    reachedSymbols: number;
+    returnedSymbols: number;
+    omittedByBudget: number;
+    unresolvedEdges: number;
+    lowConfidenceEdges: number;
+}
 /**
  * Result of a context-pack query: the set of spans needed to understand
  * how a target symbol is used across the workspace.
@@ -308,6 +366,12 @@ export interface ContextPackResult {
     note?: string;
     /** Whether source text was embedded in spans (only present when include_source was requested). */
     sourceIncluded?: boolean;
+    /** Source snippets with provenance; only present when include_source was requested. */
+    snippets?: ContextPackSnippet[];
+    /** Reach/omission and edge-resolution accounting; present on every result. */
+    coverage?: ContextPackCoverage;
+    /** Bounded, deduplicated non-fatal warnings (budget omissions, read failures, containment). */
+    warnings?: string[];
 }
 export interface AskHit {
     file: string;

package/dist/tools/repo-graph.d.ts

@@ -26,6 +26,6 @@ export { extractFileOntology } from './repo-graph/ontology';
 export type { DeadExportsOptions } from './repo-graph/query';
 export { buildOntologyPreflightPacket, getBlastRadius, getCallers, getContextPack, getDeadExports, getDependencies, getFileOntology, getGraphHealth, getGraphNode, getImporters, getKeyFiles, getLocalizationContext, getPackageBoundaries, getSymbolConsumers, isGraphFresh, resetQueryCache, } from './repo-graph/query';
 export { getGraphPath, loadGraph, loadGraphSync, loadOrCreateGraph, saveGraph, saveIfDirty, } from './repo-graph/storage';
-export type { AskHit, AskOptions, AskResult, BlastRadiusResult, BuildWorkspaceGraphOptions, CallerReference, ContextPackResult, ContextPackSpan, ConventionFact, DataOperationFact, DeadExportCandidate, DeadExportsResult, FileOntology, FileReference, FileRole, FreshnessProbeState, GraphEdge, GraphExtractionFailure, GraphExtractorInputWitness, GraphHealthResult, GraphNode, GraphUnresolvedImport, LocalizationBlock, OntologyFinding, PackageBoundarySummary, RepoGraph, RepoGraphDiagnostics, RouteFact, RouteMethod, SecurityFact, SymbolEdge, SymbolEdgeEvidence, SymbolEdgeKind, SymbolEdgeResolution, SymbolIdentityKind, SymbolReference, } from './repo-graph/types';
+export type { AskHit, AskOptions, AskResult, BlastRadiusResult, BuildWorkspaceGraphOptions, CallerReference, ContextPackCoverage, ContextPackResult, ContextPackSnippet, ContextPackSourceMode, ContextPackSpan, ConventionFact, DataOperationFact, DeadExportCandidate, DeadExportsResult, FileOntology, FileReference, FileRole, FreshnessProbeState, GraphEdge, GraphExtractionFailure, GraphExtractorInputWitness, GraphHealthResult, GraphNode, GraphUnresolvedImport, LocalizationBlock, OntologyFinding, PackageBoundarySummary, RepoGraph, RepoGraphDiagnostics, RouteFact, RouteMethod, SecurityFact, SymbolEdge, SymbolEdgeEvidence, SymbolEdgeKind, SymbolEdgeResolution, SymbolIdentityKind, SymbolReference, } from './repo-graph/types';
 export { createEmptyGraph, GRAPH_SCHEMA_VERSION, inferPackageBoundary, isSchemaVersionAtLeast, normalizeGraphPath, REPO_GRAPH_FILENAME, updateGraphMetadata, } from './repo-graph/types';
 export { validateGraphEdge, validateGraphNode, validateWorkspace, } from './repo-graph/validation';

package/dist/tools/skill-improve.d.ts

@@ -9,8 +9,15 @@
  * Closes issue #629: lets users wire an expensive OpenRouter model and cap
  * its usage to e.g. 10 calls/day.
  */
+import { findWriteApprovalFact, formatApproveWriteCommand } from '../security/write-authority.js';
 import { createSwarmTool } from './create-tool.js';
+declare const writeAuthorityDependencies: {
+    findWriteApprovalFact: typeof findWriteApprovalFact;
+    formatApproveWriteCommand: typeof formatApproveWriteCommand;
+};
 export declare const skill_improve: ReturnType<typeof createSwarmTool>;
 export declare const _internals: {
     skill_improve: typeof skill_improve;
+    writeAuthorityDependencies: typeof writeAuthorityDependencies;
 };
+export {};