@gajae-code/coding-agent 0.17.4 → 0.17.6

package/dist/types/config/file-lock.d.ts

@@ -21,12 +21,14 @@ export type FileLockAcquireReason = "acquire_timeout" | "orphan_transition";
  * generation); this records the cause that exhaustion must report.
  */
 export interface FileLockStaleRemovalFailure {
-    /** Guarded-removal outcome the acquire path can record, or `"error"` when the removal attempt threw. */
-    outcome: "cleanup_failed" | "error";
+    /** Guarded-removal outcome; refusals are surfaced only after exhaustion revalidates the dead generation. */
+    outcome: "cleanup_failed" | "owner_changed" | "missing" | "error";
     /** Native/errno code carried by the refusal, when one was present. */
     code?: string;
     /** Human-readable cause surfaced to the operator at exhaustion. */
     message: string;
+    /** Platform-specific manual cleanup command, set only when the same dead owner persists at exhaustion. */
+    manualCleanupCommand?: string;
 }
 export declare class FileLockAcquireError extends Error {
     readonly filePath: string;

package/dist/types/config/model-registry.d.ts

@@ -9,7 +9,7 @@ import { ConfigError, ConfigFile } from "./config-file";
 import { isAuthenticated, kNoAuth } from "./model-auth";
 import { type ConfiguredModelBindings } from "./model-bindings-applier";
 import { type ProviderDiscoveryState } from "./model-discovery-manager";
-import { type ModelPresetRegistryDependencies } from "./model-preset-registry";
+import { type ModelPresetRegistryDependencies, type ModelPresetRegistryRefreshResult } from "./model-preset-registry";
 export type { ProviderDiscoveryState, ProviderDiscoveryStatus } from "./model-discovery-manager";
 import { type CanonicalModelIndex, type CanonicalModelRecord, type CanonicalModelVariant, type ModelEquivalenceConfig } from "./model-equivalence";
 import { type ModelProfileDefinition } from "./model-profiles";
@@ -376,6 +376,8 @@ export declare class ModelRegistry {
      * Reload models from disk (embedded + accepted registry + custom from models.yml).
      */
     refreshStatic(): Promise<void>;
+    /** Refresh the signed profile catalog online, then publish its accepted snapshot. */
+    refreshModelPresetProfilesFromRegistry(): Promise<ModelPresetRegistryRefreshResult>;
     /**
      * Reload models from disk and refresh runtime provider discovery state.
      */

package/dist/types/config/model-resolver.d.ts

@@ -41,7 +41,7 @@ export declare function resolveStartupModelRefreshSelectors(options: {
     resume?: string | boolean;
     hasStartupProfile: boolean;
 }, settings: ModelRoleSettings): ModelSelectorValue | undefined;
-export declare function refreshMissingQualifiedModelProviders(selectors: ModelSelectorValue | undefined, modelRegistry: Pick<ModelRegistry, "getAvailable" | "getRefreshableProviders" | "refreshProvider">): Promise<boolean>;
+export declare function refreshMissingQualifiedModelProviders(selectors: ModelSelectorValue | undefined, modelRegistry: Pick<ModelRegistry, "getAvailable" | "getRefreshableProviders" | "refreshProvider">, credentialSessionId?: string): Promise<boolean>;
 /**
  * Format a model as "provider/modelId" string.
  */

package/dist/types/exec/bash-executor.d.ts

@@ -68,6 +68,8 @@ export interface BashExecutorOptions {
     sessionKey?: string;
     /** Additional environment variables to inject */
     env?: Record<string, string>;
+    /** Environment names to hide from this command's inherited environment. */
+    unsetEnv?: string[];
     /** Artifact path/id for full output storage */
     artifactPath?: string;
     artifactId?: string;

package/dist/types/extensibility/gjc-plugins/runtime-adapters.d.ts

@@ -1,6 +1,6 @@
 import type { CustomTool } from "../custom-tools/types";
 import { type SessionQuarantine } from "./session-validation";
-import type { GjcPluginScope, JsonSchema202012, NormalizedToolSurfaceV2 } from "./types";
+import type { GjcBundleIdentity, GjcPluginScope, JsonSchema202012, NormalizedToolSurfaceV2 } from "./types";
 export interface AlwaysOnPluginTools {
     tools: CustomTool[];
     quarantine: SessionQuarantine[];
@@ -9,6 +9,12 @@ export interface GjcPluginToolDeclaration extends NormalizedToolSurfaceV2 {
     plugin: string;
     scope: GjcPluginScope;
 }
+export interface GjcPluginMcpServerProvenance {
+    identity: GjcBundleIdentity;
+    surfaceId: string;
+}
+/** Bound and scrub plugin-controlled MCP causes before they enter logs or runtime findings. */
+export declare function safePluginMcpDiagnostic(value: unknown): string;
 /**
  * Return v2 tool declarations without reading or importing implementation
  * modules. This is the schema-serving path used by discovery and diagnostics.
@@ -69,11 +75,14 @@ export declare function renderSkillAdvertisement(input: {
  * Convert active plugin-bundle MCP surfaces into runtime MCPServerConfig entries,
  * applying install + runtime MCP policy (URL scheme/private-range deny, DNS
  * re-resolution for http/sse, stdio root-confinement) before connection. Servers
- * failing policy are quarantined and excluded. Returns {} when none.
+ * failing policy are quarantined and excluded. The provenance map contains
+ * only servers present in `configs`, so connection errors can be attributed to
+ * the authenticated bundle and stable surface that supplied each server.
  */
 export declare function buildPluginMcpConfigs(input: {
     cwd: string;
 }): Promise<{
     configs: Record<string, any>;
     quarantine: SessionQuarantine[];
+    serverProvenance: ReadonlyMap<string, GjcPluginMcpServerProvenance>;
 }>;

package/dist/types/gjc-runtime/state-writer.d.ts

@@ -1,4 +1,4 @@
-import type { Stats } from "node:fs";
+import { type Stats } from "node:fs";
 import { type FileLockOptions } from "../config/file-lock";
 import type { SkillActiveEntry } from "../skill-state/active-state";
 import { type AuditEntry, type CanonicalGjcWorkflowSkill, type WorkflowStateMutationOwner } from "../skill-state/workflow-state-contract";
@@ -82,6 +82,14 @@ export interface GuardedStateWriteReceipt {
 export declare function guardedStateWriteReceipt(result: GuardedWriteResult): GuardedStateWriteReceipt | undefined;
 export interface StateWriterOptions {
     cwd?: string;
+    /**
+     * Linux-only private durable source publication. The supplied directory is
+     * the exact private subtree containing the target; existing paths are never
+     * chmodded or repaired.
+     */
+    privateDurable?: {
+        directory: string;
+    };
     receipt?: StateWriterReceiptContext;
     audit?: StateWriterAuditContext;
     sourceRevision?: number;
@@ -108,6 +116,11 @@ export declare class StateWriteConflictError extends Error {
 export interface DeleteIfOwnedOptions extends StateWriterOptions {
     predicate?: (current: unknown) => boolean | Promise<boolean>;
 }
+export declare class StatePublicationUncertainError extends Error {
+    readonly path: string;
+    readonly cause: unknown;
+    constructor(path: string, cause: unknown);
+}
 export interface DeleteResult {
     path: string;
     deleted: boolean;

package/dist/types/harness-control-plane/control-endpoint.d.ts

@@ -13,7 +13,10 @@ export interface EndpointRequest {
     verb: string;
     input: Record<string, unknown>;
 }
-export type EndpointHandler = (req: EndpointRequest) => Promise<unknown>;
+export interface EndpointHandlerRequest extends EndpointRequest {
+    signal: AbortSignal;
+}
+export type EndpointHandler = (req: EndpointHandlerRequest) => Promise<unknown>;
 export declare class ControlServer {
     #private;
     readonly socketPath: string;

package/dist/types/harness-control-plane/finalize.d.ts

@@ -1,3 +1,6 @@
+import { type LinuxProcPidProbeResult } from "../gjc-runtime/linux-proc";
+import { type ReceiptEnvelope } from "./receipts";
+import { type ReceiptIndexEntry } from "./storage";
 import { type ReviewVerdict } from "./types";
 export interface ValidationCommandSpec {
     name: string;
@@ -9,14 +12,21 @@ export interface ValidationRun {
     exitStatus: number;
     pass: boolean;
 }
+export declare class ValidationObservationUncertainError extends Error {
+    readonly exactCommand: string;
+    readonly cwd: string;
+    constructor(exactCommand: string, cwd: string, cause?: unknown);
+}
 export interface FinalizeChecks {
-    runValidation(spec: ValidationCommandSpec): Promise<ValidationRun>;
+    runValidation(spec: ValidationCommandSpec, signal?: AbortSignal): Promise<ValidationRun>;
     resolveCommit(): Promise<string | null>;
     commitOnBranch(commit: string, branch: string): Promise<boolean>;
     prOrIssue(): Promise<{
         prUrl: string | null;
         issueArtifact: string | null;
     }>;
+    /** Owner-scoped receipt commit hook; null means lifecycle authority was withdrawn. */
+    writeReceipt?(family: "validation" | "completion" | "review-failure" | "review-verdict", receipt: ReceiptEnvelope<unknown>): Promise<ReceiptIndexEntry | null>;
 }
 export interface FinalizeOptions {
     root: string;
@@ -39,6 +49,8 @@ export interface FinalizeOptions {
     prTarget?: string | null;
     validationCommands?: ValidationCommandSpec[];
     checks: FinalizeChecks;
+    /** Cancels an in-flight validation subprocess when its owning request is withdrawn. */
+    signal?: AbortSignal;
     clock?: () => number;
 }
 export interface FinalizeResult {
@@ -56,5 +68,4 @@ export interface FinalizeResult {
     blockers: string[];
 }
 export declare function runFinalize(opts: FinalizeOptions): Promise<FinalizeResult>;
-/** Real checks: git for commit/branch, gh for PR, Bun.spawn for validation commands. */
-export declare function defaultFinalizeChecks(workspace: string): FinalizeChecks;
+export declare function defaultFinalizeChecks(workspace: string, probeProcess?: (pid: number) => LinuxProcPidProbeResult): FinalizeChecks;

package/dist/types/main.d.ts

@@ -58,7 +58,7 @@ type StartupModelProfileArgs = {
     session: AgentSession;
     settings: Settings;
     modelRegistry: ModelRegistry;
-    parsedArgs: Pick<Args, "default" | "model" | "mpreset" | "thinking">;
+    parsedArgs: Pick<Args, "continue" | "default" | "fork" | "model" | "mpreset" | "resume" | "thinking">;
     startupModel?: CreateAgentSessionOptions["model"];
     startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
     preferCachedModels?: boolean;

package/dist/types/runtime-mcp/loader.d.ts

@@ -2,6 +2,7 @@ import type { LoadedCustomTool } from "../extensibility/custom-tools/types";
 import { AgentStorage } from "../session/agent-storage";
 import type { AuthStorage } from "../session/auth-storage";
 import { MCPManager } from "./manager";
+import { MCPToolCache } from "./tool-cache";
 /** Result from loading MCP tools */
 export interface MCPToolsLoadResult {
     /** MCP manager (for lifecycle management) */
@@ -37,6 +38,7 @@ export interface MCPToolsLoadOptions {
     /** Idle retention for shared MCP pool entries. */
     sharedPoolIdleMs?: number;
 }
+export declare function resolveMCPToolCache(storage?: AgentStorage | null, dbPath?: string): Promise<MCPToolCache | null>;
 /**
  * Discover and load MCP tools from .mcp.json files.
  *

package/dist/types/runtime-mcp/manager.d.ts

@@ -98,10 +98,10 @@ export interface MCPManagerOptions {
     /** Restrict this instance to tools from an explicit MCP config. */
     toolsOnly?: boolean;
     /**
-     * Ceiling for the startup wait, in milliseconds. Only ACP lifecycle launches
-     * set this, so a slow ACP MCP handshake gets the readiness budget while every
-     * other consumer keeps the short default. Non-positive or non-finite values
-     * are ignored and the default applies.
+     * Ceiling for the startup wait, in milliseconds. ACP lifecycle launches and
+     * plugin MCP startup use bounded caller-owned budgets; other consumers keep
+     * the short default. Non-positive or non-finite values are ignored and the
+     * default applies.
      */
     maxStartupTimeoutMs?: number;
     /** Connection pool used for every physical MCP open/close. */
@@ -110,6 +110,8 @@ export interface MCPManagerOptions {
     sessionId?: string;
     /** Idle retention for shared pool entries. */
     sharedPoolIdleMs?: number;
+    /** Limit tool-cache reads and writes to this manager's conventional servers. */
+    toolCacheServerNames?: ReadonlySet<string>;
     /** Test seam for deterministic reconnect backoff scheduling. */
     sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
     /** Test seam for fencing the acquisition-to-registration replacement race. */
@@ -157,7 +159,10 @@ export declare class MCPManager {
     static setInstance(value: MCPManager | undefined): void;
     /** Reset the process-global instance. Test-only. */
     static resetForTests(): void;
+    /** Block config mutations and reloads while keeping existing servers reconnectable. */
+    freezeConnectionSet(): void;
     sealConnectionSet(): void;
+    isConnectionSetMutationBlocked(): boolean;
     isConnectionSetSealed(): boolean;
     constructor(cwd: string, toolCache?: MCPToolCache | null, options?: MCPManagerOptions);
     isToolsOnly(): boolean;
@@ -166,9 +171,11 @@ export declare class MCPManager {
      */
     setOnNotification(handler: (serverName: string, method: string, params: unknown) => void): void;
     /**
-     * Set a callback to fire when any server's tools change.
+     * Set a callback to receive a read-only catalog snapshot when server tools change.
      */
-    setOnToolsChanged(handler: (tools: CustomTool<TSchema, MCPToolDetails>[]) => void): void;
+    setOnToolsChanged(handler: (tools: readonly Readonly<CustomTool<TSchema, MCPToolDetails>>[]) => void): void;
+    /** Subscribe to readonly catalog snapshots without replacing the manager owner's callback. */
+    subscribeToToolsChanged(handler: (tools: readonly Readonly<CustomTool<TSchema, MCPToolDetails>>[]) => void): () => void;
     /**
      * Set a callback to fire when any server's resources change.
      */

package/dist/types/sdk/broker/broker.d.ts

@@ -94,7 +94,7 @@ export type BrokerCleanupEvidence = {
         dev: string;
         ino: string;
     };
-    /** Identity-bound lifecycle metadata marker retained when exact cleanup is deferred. */
+    /** Identity-bound lifecycle metadataker retained when exact cleanup is deferred. */
     metadataIdentity?: BrokerCleanupIdentity;
     metadataPath?: string;
     /** Monotonic append-only cleanup attempt. */
@@ -129,7 +129,7 @@ export type BrokerCleanupEvidence = {
         dev: string;
         ino: string;
     };
-    /** Delete metadata receipts authorize only the canonical marker/ready sibling pair. */
+    /** Delete metadata receipts authorize only the canonicalker/ready sibling pair. */
     lifecycleDeleteMetadata?: true;
 };
 export type BrokerResponse = {
@@ -379,6 +379,8 @@ export declare function setAmbiguityGraceForTest(broker: Broker, graceMs: number
 export declare function setLockArtifactGraceForTest(broker: Broker, graceMs: number | undefined): void;
 /** Test-only hook for shortening the bounded liveness deadline. */
 export declare function setLivenessGraceForTest(broker: Broker, graceMs: number | undefined): void;
+/** Test-only hook for shortening the bounded wait before a deferred managed close is queued. */
+export declare function setManagedCloseWaitForTest(broker: Broker, waitMs: number | undefined): void;
 /**
  * Test-only hook for stalling the heartbeat write, reproducing a publication tick
  * whose awaited IO does not settle. Clearing it releases the stalled tick the way

package/dist/types/sdk/broker/ensure.d.ts

@@ -3,6 +3,7 @@ import type { FileHandle } from "node:fs/promises";
 import { type FileLockOptions } from "../../config/file-lock";
 import { type BrokerDiscovery } from "./discovery";
 import { type SdkInternalSpawnCommand } from "./runtime";
+import { type BrokerStartupFailureMarker } from "./startup-failure";
 export declare function isBrokerGenerationCompatible(discovery: BrokerDiscovery | null): boolean;
 /**
  * A live incumbent stops being reusable once the runtime image it launches
@@ -173,4 +174,6 @@ export declare function reapSpawnedBrokerForTest(child: ChildProcess, timing?: R
 export declare function brokerSpawnEnvironmentForTest(command: SdkInternalSpawnCommand, override?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /** Test hook: installs an exact controllable owner to exercise replacement fencing. */
 export declare function registerBrokerOwnerForTest(agentDir: string, child: ChildProcess, timing?: ReapTiming): BrokerOwner;
+/** Test hook: exercises the same trusted-marker reason reconstruction used by ensureBroker. */
+export declare function brokerStartupFailureReasonForTest(marker: BrokerStartupFailureMarker | undefined): string;
 export {};

package/dist/types/sdk/broker/identity.d.ts

@@ -1,6 +1,8 @@
 export declare function brokerIdentityPath(agentDir: string): string;
 export declare function getBrokerIdentityKey(agentDir: string): Promise<string>;
 export declare function deriveIdempotencyIdentity(agentDir: string, operation: string, callerKey: string, targetHash?: string): Promise<string>;
+/** Native identity for an idempotency key reserved inside one managed control root. */
+export declare function deriveScopedIdempotencyIdentity(agentDir: string, operation: string, callerKey: string, scope: string): Promise<string>;
 /** Identity format used by lifecycle rows written before target binding. */
 export declare function deriveLegacyIdentity(agentDir: string, operation: string, callerKey: string): Promise<string>;
 export declare function deriveLegacyTargetIdentity(agentDir: string, operation: string, callerKey: string, canonicalTargetHash: string): Promise<string>;

package/dist/types/sdk/broker/lifecycle-ledger.d.ts

@@ -142,11 +142,19 @@ export declare class LifecycleLedger {
     findByOperationKey(operationKey: string, fingerprint?: string): LifecycleLedgerEntry | undefined;
     findAnyByOperationKey(operationKey: string): LifecycleLedgerEntry | undefined;
     /**
-     * Legacy target-inclusive rows predate the operation/key index. Their opaque
+     * Live or uncertain legacy rows predate the operation/key index. Their opaque
      * identities cannot establish that a different target is safe, so callers
-     * must reject rather than create a second admission.
+     * must reject rather than create a second admission. A fresh session.create
+     * may ignore completed terminal legacy rows so old successful operations do
+     * not block coordinator startup. Other operations retain the legacy fence
+     * because target-bound legacy identities cannot prove key uniqueness. For
+     * target-bound terminal creates, the opaque legacy identity also cannot reveal
+     * the original caller key, so this exception retires that legacy key history;
+     * exact key-only legacy creates are still rejected by the earlier lookup.
      */
-    hasLegacyIdentity(excludedIdentities?: ReadonlySet<string>): boolean;
+    hasLegacyIdentity(excludedIdentities?: ReadonlySet<string>, options?: {
+        ignoreTerminalRows?: boolean;
+    }): boolean;
     migrateIdentity(from: string, to: string, metadata: {
         operationKey: string;
         fingerprint: string;