@gajae-code/coding-agent 0.17.2 → 0.17.5

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;
@@ -89,7 +91,14 @@ export interface FileLockOwnerToken {
 }
 /** Outcome of a guarded lock-dir removal attempt (`removeFileLockDirForGc`). */
 export type FileLockGcRemoval = "removed" | "owner_changed" | "missing" | "cleanup_failed";
-/** Identity evidence carried by the generic stale verdict into a later removal. */
+/**
+ * Identity evidence carried by the generic stale verdict into a later removal.
+ *
+ * `ctimeNs` is a mutable metadata-change time on every supported filesystem, so
+ * it is retained for diagnostics/legacy consumers but is not part of the lock
+ * identity predicate. `infoBirthtimeNs` is the creation time that stays bound
+ * to the file object.
+ */
 export interface GenericFileLockDirIdentity {
     rootDev: string;
     rootIno: string;
@@ -99,6 +108,7 @@ export interface GenericFileLockDirIdentity {
     infoSize: string;
     infoMtimeNs: string;
     infoCtimeNs: string;
+    infoBirthtimeNs: string;
     infoSha256: string;
 }
 export type GenericFileLockDirStaleVerdict = {

package/dist/types/config/model-profile-activation.d.ts

@@ -31,7 +31,7 @@ type ModelProfileActivationSession = Pick<AgentSession, "model" | "thinkingLevel
     getDefaultFallbackRuntimeState?: () => DefaultFallbackRuntimeState;
     restoreDefaultFallbackRuntimeState?: (state: DefaultFallbackRuntimeState) => void;
     restoreModelSelectionForRollback?: AgentSession["restoreModelSelectionForRollback"];
-    modelRegistry?: Pick<ModelRegistry, "getSessionCanonicalVariant" | "restoreSessionCanonicalVariant" | "clearCanonicalVariant" | "getAvailable" | "lookupAliasExists" | "resolveModelByLookupAlias" | "authStorage" | "isCredentiallessProvider">;
+    modelRegistry?: Pick<ModelRegistry, "getSessionCanonicalVariant" | "restoreSessionCanonicalVariant" | "clearCanonicalVariant" | "getAvailable" | "lookupAliasExists" | "resolveModelByLookupAlias" | "authStorage" | "isCredentiallessProvider"> & Partial<Pick<ModelRegistry, "getAvailableForProfileActivation">>;
     getConfiguredModelChainState?: (role: string) => ConfiguredModelChainState | undefined;
 };
 type ConfiguredModelChainState = {
@@ -182,6 +182,48 @@ export declare function getProxyRoutableProviders(profile: ModelProfileDefinitio
  * retain their legacy tolerance for stale qualified role tails.
  */
 export declare function requiresQualifiedModelProfileRoleResolution(profile: Pick<ModelProfileDefinition, "source">): boolean;
+/** Resolve a removed saved-session default through the durable profile without mutating persistent state. */
+export declare function resolveMissingSessionModelRecovery(options: {
+    modelRegistry: PrepareModelProfileActivationOptions["modelRegistry"];
+    settings: Pick<Settings, "get" | "getModelRole">;
+    defaultEntries: readonly string[];
+    skips: Array<{
+        selector: string;
+        reason: string;
+    }>;
+    savedDefault: string | undefined;
+    credentialSessionId: string;
+    aliasIntent?: "preset-equivalent";
+}): Promise<{
+    profileName: string;
+    entries: string[];
+    model?: Model<Api>;
+    thinkingLevel?: ThinkingLevel;
+    explicitThinkingLevel: boolean;
+    activeIndex: number;
+    skips: Array<{
+        selector: string;
+        reason: string;
+    }>;
+} | undefined>;
+/** Resolve a durable profile's effective default chain without mutating session or settings state. */
+export declare function resolveModelProfileDefaultChain(options: {
+    modelRegistry: PrepareModelProfileActivationOptions["modelRegistry"];
+    settings: Pick<Settings, "get">;
+    profileName: string;
+    credentialSessionId: string;
+}): Promise<{
+    profileName: string;
+    entries: string[];
+    model?: Model<Api>;
+    thinkingLevel?: ThinkingLevel;
+    explicitThinkingLevel: boolean;
+    activeIndex: number;
+    skips: Array<{
+        selector: string;
+        reason: string;
+    }>;
+}>;
 export declare function rewriteSelectorForProxy(selector: string, proxyProvider: string, proxyMode: ModelProfileProxyMode, allModels: Model<Api>[], directlyAuthenticated: ReadonlySet<string>, routableProviders: ReadonlySet<string>): string;
 export declare function prepareModelProfileActivation(options: PrepareModelProfileActivationOptions): Promise<PreparedModelProfileActivation>;
 export declare function applyPreparedModelProfileActivation(prepared: PreparedModelProfileActivation, options?: ApplyModelProfileActivationOptions): Promise<void>;
@@ -218,3 +260,5 @@ export declare function restoreMaterializedModelProfileForDeletion(options: {
     snapshot: MaterializeModelProfileForDeletionResult;
 }): Promise<void>;
 export declare function activateModelProfile(options: PrepareModelProfileActivationOptions, applyOptions?: ApplyModelProfileActivationOptions): Promise<void>;
+/** Install only a profile's runtime role layer, preserving session model and configured-chain intent. */
+export declare function applyModelProfileRuntimeBindings(options: PrepareModelProfileActivationOptions): Promise<void>;

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";
@@ -20,6 +20,12 @@ export type { BillingPath, BillingPathKind } from "./billing-path";
 export type { EffectiveProviderAuth, ProviderSelectionPolicy } from "./provider-selection-policy";
 export type { CanonicalModelIndex, CanonicalModelRecord, CanonicalModelVariant, ModelEquivalenceConfig };
 export { isAuthenticated, kNoAuth };
+/**
+ * Scrub resolved credential material from a discovery failure before it is
+ * published to discovery state, cache provenance, or the logger. Mutates
+ * Error messages and stacks in place to preserve class/identity; wraps non-Errors.
+ */
+export declare function scrubDiscoveryError(error: unknown, secrets: ReadonlyArray<string | undefined>): unknown;
 /**
  * A loopback discovery endpoint that is proven to have no listener is the normal state of
  * a machine without a local model server. Structured transport evidence is required when
@@ -321,6 +327,7 @@ interface ProviderOverride {
     cacheRetention?: CacheRetention;
     isOAuth?: boolean;
 }
+export declare function registrySelectorResolvesToModel(selector: string, models: readonly Model<Api>[]): boolean;
 /**
  * Merge a freshly discovered model with the matching bundled/configured entry
  * (or a runtime provider override when no bundled entry exists).
@@ -369,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.
      */
@@ -523,8 +532,10 @@ export declare class ModelRegistry {
      */
     seedCanonicalVariant(sessionId: string, model: Model<Api>): boolean;
     /**
-     * Get only models that have auth configured.
-     * This is a fast check that doesn't refresh OAuth tokens.
+     * Get selectable models with auth configured.
+     * This is a fast check that doesn't refresh OAuth tokens. A current,
+     * authoritative live catalog also limits each provider to its enrolled ids;
+     * bundled entries remain the fallback until that evidence exists.
      */
     getAvailable(): Model<Api>[];
     /**

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/config/settings-schema.d.ts

@@ -157,6 +157,12 @@ export interface ModelTagsSettings {
     [key: string]: ModelTagDef;
 }
 export declare const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[];
+export declare const DEFAULT_SDK_PROMPT_DEADLINE_MS = 3600000;
+export declare const DEFAULT_SDK_PROMPT_MAX_RUNTIME_MS = 21600000;
+/** Resolve a `sdk.promptDeadlineMs` lookup, falling back on any non-finite value. */
+export declare function resolveSdkPromptDeadlineMs(value: unknown): number;
+/** Resolve a `sdk.promptMaxRuntimeMs` lookup, falling back on any non-finite value. */
+export declare function resolveSdkPromptMaxRuntimeMs(value: unknown): number;
 export declare const SETTINGS_SCHEMA: {
     readonly lastChangelogVersion: {
         readonly type: "string";
@@ -219,6 +225,11 @@ export declare const SETTINGS_SCHEMA: {
         readonly description: "Hard maximum runtime for an SDK prompt from acceptance, bounding progress-aware renewals.";
         readonly validate: (value: number) => boolean;
     };
+    readonly "sdk.flushWorktreeOnDeadline": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly description: "Autosave uncommitted changes in the session's linked worktree by default as a WIP commit when a prompt deadline retires a prompt; primary checkouts require an explicit true opt-in.";
+    };
     readonly "sdk.masterOrphanGraceMs": {
         readonly type: "number";
         readonly default: 120000;

package/dist/types/coordinator-mcp/question-state.d.ts

@@ -454,7 +454,12 @@ export declare function readSchedulerRoster(paths: CoordinatorStatePaths, option
 export declare function advanceSchedulerCursor(paths: CoordinatorStatePaths, cursor: string, options?: {
     signal?: AbortSignal;
 }): Promise<void>;
-export declare function readSessionTransaction(paths: CoordinatorStatePaths, sessionId: string): Promise<CoordinatorSessionTransactionV1 | null>;
+export declare function readSessionTransaction(paths: CoordinatorStatePaths, sessionId: string, options?: {
+    signal?: AbortSignal;
+}): Promise<CoordinatorSessionTransactionV1 | null>;
+export declare function repairLegacyReportIds(paths: CoordinatorStatePaths, sessionId: string, options?: {
+    signal?: AbortSignal;
+}): Promise<CoordinatorSessionTransactionV1 | null>;
 export declare function withSessionTransaction<T>(paths: CoordinatorStatePaths, sessionId: string, operation: (transaction: CoordinatorSessionTransactionV1) => Promise<T>, options?: {
     signal?: AbortSignal;
 }): Promise<T>;

package/dist/types/daemon/operator-contract.d.ts

@@ -24,11 +24,15 @@ export declare const DAEMON_ACTION_ALIASES: Readonly<Record<string, DaemonAction
 export declare const DAEMON_ACTION_TOKENS: readonly string[];
 /** Resolve a leading verb (canonical or alias) to its canonical action. */
 export declare function resolveDaemonAction(token: string | undefined): DaemonAction | undefined;
-/** Exit codes for `gjc daemon`. Backward compatible: success 0, any failure 1. */
+/** Public input failures exit 2; operational failures retain exit 1. */
 export declare const DAEMON_EXIT: {
     readonly ok: 0;
     readonly failure: 1;
+    readonly usage: 2;
 };
+/** A refused result may follow a successful stop or spawn; snapshots and prose
+ * do not prove that no effect occurred. Only completed results prove applied. */
+export declare function daemonOperationOutcome(result: DaemonOperationResult): "applied" | "unknown";
 /** Human-facing headline when a spawn/reload is refused by a live foreign identity. */
 export declare const OWNERSHIP_MISMATCH_MESSAGE = "refused: a live Telegram daemon with a different bot token or chat already owns this workspace";
 /** Structured, actionable recovery for a token/chat ownership mismatch. */

package/dist/types/eval/js/worker-protocol.d.ts

@@ -10,6 +10,8 @@ export interface RunErrorPayload {
     stack?: string;
     isAbort?: boolean;
     isToolError?: boolean;
+    /** Set only when the originating error carried the trusted designed marker. */
+    isDesigned?: boolean;
 }
 export type ToolReply = {
     ok: true;

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/extensions/types.d.ts

@@ -31,6 +31,7 @@ import type { AgentSessionEventListener } from "../../session/agent-session";
 import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "../../session/client-bridge";
 import type { CustomMessage } from "../../session/messages";
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager";
+import type { SessionWorkLease } from "../../session/session-work-lease";
 import type { BashToolDetails, BashToolInput, FindToolDetails, FindToolInput, ReadToolDetails, ReadToolInput, SearchToolDetails, SearchToolInput, WriteToolInput } from "../../tools";
 import type { EventBus } from "../../utils/event-bus";
 import type { AgentEndEvent, AutoCompactionEndEvent, AutoCompactionStartEvent, AutoRetryEndEvent, AutoRetryStartEvent, ContextEvent, GoalUpdatedEvent, SessionBeforeBranchEvent, SessionBeforeBranchResult, SessionBeforeCompactEvent, SessionBeforeCompactResult, SessionBeforeSwitchEvent, SessionBeforeSwitchResult, SessionBeforeTreeEvent, SessionBeforeTreeResult, SessionBranchEvent, SessionCompactEvent, SessionCompactingEvent, SessionCompactingResult, SessionEvent, SessionShutdownEvent, SessionStartEvent, SessionSwitchEvent, SessionTreeEvent, AgentStartEvent as SharedAgentStartEvent, TodoReminderEvent, ToolCallEventResult, ToolResultEventResult, TtsrTriggeredEvent, TurnEndEvent, TurnStartEvent } from "../shared-events";
@@ -279,6 +280,8 @@ export interface ExtensionContext {
     isIdle(): boolean;
     /** Stable resource ownership identifier for the active prompt run. */
     getActivePromptHandle(): string | undefined;
+    /** The session's authoritative host-liveness lease. */
+    getSessionWorkLease?(): SessionWorkLease | undefined;
     /** Abort the current agent operation */
     abort(): void | Promise<void>;
     /** Abort and prove whether resources for a specific prompt settled. */
@@ -1044,6 +1047,13 @@ export type SendUserMessageHandler = (content: string | (TextContent | ImageCont
         startsOwnRun?: boolean;
         removed?: boolean;
     }) => void;
+    /**
+     * Fired synchronously when a plain prompt's dispatch resolves at queue
+     * time instead of run end (diverted into an in-flight run's steering).
+     */
+    onDispatchDisposition?: (promotion: {
+        startsOwnRun: boolean;
+    }) => void;
     preflightSignal?: AbortSignal;
 }) => void | Promise<void>;
 export type AppendEntryHandler = <T = unknown>(customType: string, data?: T) => void;
@@ -1111,6 +1121,8 @@ export interface ExtensionContextActions {
     isIdle: () => boolean;
     /** Stable resource ownership identifier for the active prompt run. */
     getActivePromptHandle?: () => string | undefined;
+    /** The session's authoritative host-liveness lease. */
+    getSessionWorkLease?: () => SessionWorkLease | undefined;
     abort: () => void | Promise<void>;
     abortPromptAndWait?: (handle: string, options: {
         graceMs: number;

package/dist/types/extensibility/gjc-plugins/registry.d.ts

@@ -1,4 +1,8 @@
 import { type GjcPluginRegistry, type GjcPluginRegistryEntry, type GjcPluginScope } from "./types";
+export declare const RegistryLockTestHooks: {
+    beforeEviction?: (lockPath: string, raw: string) => void | Promise<void>;
+    beforePublish?: (stagingPath: string, lockPath: string) => void | Promise<void>;
+};
 export declare function registryRootForScope(scope: GjcPluginScope, cwd: string): string;
 export declare function registryPathForScope(scope: GjcPluginScope, cwd: string): 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/extensibility/runtime-skill-discovery.d.ts

@@ -23,6 +23,16 @@ export interface RuntimeSkillDiscoveryResult {
     candidates: RuntimeSkillDiscoveryCandidate[];
     /** Deduped skill metadata the query filter ran against, including bundled entries; candidates.length <= scanned. */
     scanned: number;
+    /**
+     * Skills left after the query filter, before the page slice: the denominator
+     * a page is a page *of*. `scanned` counts everything the filter ran against,
+     * so it cannot serve this role.
+     */
+    matching: number;
+    /** Normalized zero-based offset the returned page starts at. */
+    offset: number;
+    /** Offset of the next page, present only while one exists; omitted on the final page. */
+    nextOffset?: number;
     diagnostics: RuntimeSkillDiscoveryDiagnostics;
 }
 export interface DiscoverRuntimeSkillsOptions {
@@ -33,9 +43,17 @@ export interface DiscoverRuntimeSkillsOptions {
     profileAuthority?: "default" | "custom";
     query?: string;
     limit?: number;
+    /** Zero-based index into the matching set the returned page starts at; defaults to 0. */
+    offset?: number;
     source?: RuntimeSkillDiscoveryScope | "all";
     policy?: SkillsSettings;
 }
+/**
+ * Upper bound every caller's `limit` clamps to. Exported so `gjc skills discover`
+ * can default a human to the widest page the library will serve instead of the
+ * model-context-sized `DEFAULT_LIMIT`.
+ */
+export declare const SKILL_DISCOVERY_MAX_LIMIT = 50;
 /**
  * Explain an empty result that is caused by disabled discovery config rather
  * than by an actually empty skill catalog. Uses the user-facing trust

package/dist/types/extensibility/shared-events.d.ts

@@ -81,9 +81,11 @@ export interface SessionCompactEvent {
     /** Whether the compaction entry was provided by an extension/hook */
     fromExtension: boolean;
 }
-/** Fired on process exit (SIGINT/SIGTERM) */
+/** Fired during session teardown, including process exit and SDK host self-reap. */
 export interface SessionShutdownEvent {
     type: "session_shutdown";
+    /** Set only when the SDK host reaped itself after detached-idle grace. */
+    reason?: "detached_idle";
 }
 /** Preparation data for tree navigation (used by session_before_tree event) */
 export interface TreePreparation {

package/dist/types/gjc-runtime/session-state-lock.d.ts

@@ -1,3 +1,4 @@
+import { type LinuxProcPidProbeResult } from "./linux-proc";
 /**
  * How a `<file>.lock` owner record can be opened safely on this platform.
  *
@@ -43,6 +44,13 @@ export declare const SessionStateLockTestHooks: {
      * configuration.
      */
     probeProcessSignal?: (pid: number) => void;
+    /**
+     * @internal How an owner pid's `/proc` entry is read. Whether a killed pid is still an
+     * unreaped zombie depends on when its parent happens to reap it, so it cannot be
+     * arranged deterministically from a test. Production code never sets it, and it is
+     * never serialized or exposed as runtime configuration.
+     */
+    probeLinuxProcPid?: (pid: number) => LinuxProcPidProbeResult;
     /**
      * @internal Runs inside a NEW owner record's write, after the exclusive create has
      * taken the pathname and before the record's bytes land. Throwing from it fails that
@@ -90,6 +98,32 @@ export declare const SessionStateLockTestHooks: {
 };
 /** Raised when the lock could not be acquired; callers map it to their own refusal. */
 export type SessionStateLockUnavailableReason = "acquire_timeout" | "legacy_directory_owner_unprovenanced" | "lock_initialization_failed" | "lock_inspection_failed" | "lock_owner_live_or_unverifiable" | "lock_owner_record_fresh" | "lock_owner_record_unprovenanced" | "lock_release_failed" | "transition_claim_timeout" | "unsafe_lock_path_type";
+/**
+ * Why a stale-transition reclaim refused, as a bounded classifier.
+ *
+ * `transition_claim_timeout` collapsed several structurally different refusals into
+ * one message, so an operator could not tell a foreign-host tombstone from a
+ * live owner from a directory an external process was stamping — the gap #5606
+ * asked for. Every member is a fixed enum: never a path, token, host id, pid or
+ * raw errno, because this rides on an error message users paste into reports.
+ */
+export type TransitionReclaimRefusal = 
+/** The claim vanished, or its owner sidecar was absent/unparseable/invalid. */
+"claim_or_owner_unreadable"
+/** A released tombstone carrying no `owner_host_id` at all. */
+ | "released_owner_unprovenanced"
+/** A released tombstone belonging to a different installation. */
+ | "released_owner_foreign_host"
+/** A released tombstone still inside `RELEASED_TRANSITION_GRACE_MS`. */
+ | "released_owner_within_grace"
+/** The owner is alive, or its liveness could not be disproven. */
+ | "owner_live_or_unverifiable"
+/** The claim changed between inspection and capture — an external writer. */
+ | "claim_generation_changed"
+/** The claim was not empty when captured, so it is not ours to remove. */
+ | "claim_not_empty"
+/** The claim's canonical path or directory snapshot could not be taken. */
+ | "claim_capture_failed";
 interface SessionStateLockUnavailableDetails {
     lockPath: string;
     reason: SessionStateLockUnavailableReason;
@@ -170,6 +204,33 @@ export declare function setSessionStateLockNativeBindings(load: SessionStateLock
  * and deletion has a different inode identity and is refused by construction.
  */
 export declare function removeVerifiedEmptyQuarantine(directory: string, name: string): Promise<void>;
+/**
+ * Outcome of one stale-transition reclaim attempt. `reclaimed` drives the
+ * caller's retry accounting exactly as the previous boolean did; `refusal`
+ * exists only so the eventual `transition_claim_timeout` can name which
+ * precondition said no (#5606).
+ */
+interface TransitionReclaimOutcome {
+    reclaimed: boolean;
+    reclaimReason?: "released_handoff" | "dead_owner";
+    refusal?: TransitionReclaimRefusal;
+}
+/**
+ * Classify one stale-transition reclaim attempt.
+ *
+ * @internal exported as the seam the refusal classifier is tested through. Driving
+ * a real `transition_claim_timeout` would mean waiting out `LOCK_ACQUIRE_MAX_WAIT_MS`
+ * (60s) per case, and `tryWithSessionStateFileLock` throws BUSY before the timeout
+ * is ever built, so the per-branch reasons have no other reachable surface (#5606).
+ */
+export declare function classifyTransitionReclaimForTests(transitionDir: string, quarantineName: string): Promise<TransitionReclaimOutcome>;
+/**
+ * Build the timeout error exactly as the transition loop does.
+ *
+ * @internal exported so the message contract — a bounded enum suffix and nothing
+ * else — is pinned without a 60s wait (#5606).
+ */
+export declare function transitionClaimTimeoutForTests(transitionDir: string, refusal: TransitionReclaimRefusal | undefined): SessionStateLockUnavailableError;
 export declare function reclaimStaleSessionStateLock(lockFile: string, quarantineName?: string): Promise<void>;
 /**
  * Serialize one read-modify-write of `stateFile` against every other holder of

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/internal-urls/embedded-protocol.d.ts

@@ -0,0 +1,9 @@
+import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+/**
+ * Handler for `embedded:` URLs.
+ */
+export declare class EmbeddedProtocolHandler implements ProtocolHandler {
+    readonly scheme = "embedded";
+    readonly immutable = true;
+    resolve(url: InternalUrl): Promise<InternalResource>;
+}

package/dist/types/internal-urls/index.d.ts

@@ -9,6 +9,7 @@
  */
 export * from "./agent-protocol";
 export * from "./artifact-protocol";
+export * from "./embedded-protocol";
 export * from "./gjc-protocol";
 export * from "./issue-pr-protocol";
 export * from "./json-query";

package/dist/types/internal-urls/parse.d.ts

@@ -10,10 +10,18 @@
  * MUST use this function instead of calling `new URL()` directly.
  */
 import type { InternalUrl } from "./types";
+/**
+ * Canonicalize an internal URL so slashless schemes carry an authority.
+ *
+ * Every entry point that inspects or routes an internal URL (router,
+ * read/write tools, selector splitting) MUST normalize first, so handlers only
+ * ever see the `scheme://authority/path` form.
+ */
+export declare function normalizeInternalUrlInput(input: string): string;
 /**
  * Parse an internal URL into an InternalUrl.
  *
  * Handles URLs where `new URL()` would fail (e.g., `skill://plugin:name`
  * where the colon is not a port separator).
  */
-export declare function parseInternalUrl(input: string): InternalUrl;
+export declare function parseInternalUrl(rawInput: string): InternalUrl;