@gajae-code/coding-agent 0.17.2 → 0.17.5

package/dist/types/session/session-manager.d.ts

@@ -658,7 +658,44 @@ export declare const RESUME_TRANSCRIPT_MAX_BYTES: number;
  * source exactly at the advertised limit.
  */
 export declare const BOUNDED_RESUME_TRANSCRIPT_MAX_BYTES: number;
-export declare const SESSION_OVERSIZED_RECOVERY_MESSAGE = "The selected session transcript is too large to resume safely. Use `gjc export <session-file>` to export its content into a new session, or remove/archive it after confirming its content is no longer needed.";
+/**
+ * Recovery actions offered when a live transcript is at or past the managed
+ * per-file cap.
+ *
+ * Constrained three ways, and every command named here satisfies all three:
+ *
+ * 1. **It must exist.** `gjc export <session-file>` was advised for both limits
+ *    and is not a subcommand, so following it literally started a fresh agent
+ *    that read "export" as a prompt while the session stayed unwritable. (The
+ *    root `--export` flag renders HTML and exits; it yields no resumable
+ *    session.)
+ * 2. **It must be reachable on every surface that renders the message.** These
+ *    strings reach ACP/text consumers through `AgentSession`, and the ACP
+ *    registry is filtered to definitions carrying `handle`
+ *    (`slash-commands/acp-builtins.ts`), so a `handleTui`-only command such as
+ *    `/new` is a different dead end rather than a fix.
+ * 3. **It must not drop the retained near-limit entries.** A failed append is
+ *    kept in memory with a full rewrite armed, and a rejected managed rewrite
+ *    likewise retains its resident entries; both messages promise the work
+ *    persists on the next successful write. `/compact` and `/clear` keep the
+ *    manager — and therefore that pending debt — alive; a session switch closes
+ *    the writer without paying it.
+ *
+ * Every near-limit error class MUST interpolate this constant rather than
+ * restate the advice. `SessionNearLimitRewriteError` restated it and thereby
+ * reintroduced `gjc export <session-file>` after #5621 removed it (#5691).
+ *
+ * `session-recovery-guidance.test.ts` pins all three constraints against the
+ * CLI, builtin, and ACP registries, for every near-limit error class.
+ */
+export declare const SESSION_LIMIT_RECOVERY_ACTIONS = "compact the session (`/compact`), or clear its context (`/clear`) if compaction cannot reclaim enough";
+/**
+ * Oversized-resume guidance. This surface is reached *before* a session is
+ * opened, so it deliberately does not reuse {@link SESSION_LIMIT_RECOVERY_ACTIONS}:
+ * an in-session command there would act on whichever session the user resumes
+ * next, never on the transcript that was just rejected.
+ */
+export declare const SESSION_OVERSIZED_RECOVERY_MESSAGE = "The selected session transcript is too large to resume safely. Resume a different session, or remove/archive this transcript after confirming its content is no longer needed.";
 export declare class SessionAppendPersistenceError extends Error {
     readonly phase: SessionAppendPersistenceFailurePhase;
     readonly entryId: string;
@@ -692,6 +729,28 @@ export declare class SessionNearLimitAppendError extends Error {
         entryRetained: boolean;
     });
 }
+/**
+ * Typed near-limit rewrite outcome (follow-up to #4566).
+ *
+ * A managed atomic rewrite (`#writeEntriesAtomicallySync`) whose serialized
+ * transcript crosses the per-file cap cannot be published: the managed store
+ * rejects the bytes with `content_too_large`. Unlike the append path there is
+ * no appended entry here — the whole live transcript is the payload — so this
+ * error carries the rejected rewrite size and the cap instead of append
+ * fields, and every rewrite/flush/close caller can point at compaction or
+ * export as the continuation path.
+ */
+export declare class SessionNearLimitRewriteError extends Error {
+    readonly code: "near_limit_rewrite";
+    /** Serialized transcript size (bytes) rejected by the managed store. */
+    readonly transcriptBytes: number;
+    /** Managed per-file cap in force when the rewrite was rejected. */
+    readonly capBytes: number;
+    constructor(details: {
+        transcriptBytes: number;
+        capBytes: number;
+    });
+}
 export declare class SessionManagedStorageError extends Error {
     readonly code = "managed_storage_unsupported";
     constructor();
@@ -1037,6 +1096,7 @@ export declare const SessionManagerTestHooks: {
     afterForkTranscriptPublished?: () => void | Promise<void>;
     beforeEphemeralArtifactManagerInstall?: (dir: string) => void | Promise<void>;
     beforePersistPatchFence?: (attempt: number) => void;
+    beforeLivePickerStarFence?: () => void;
     beforeStrictMissingCheck?: (filePath: string, storage: SessionStorage) => void;
     beforeManagedResumeAcceptance?: (filePath: string, storage: SessionStorage) => void;
     beforeManagedResumeReturn?: (filePath: string, storage: SessionStorage) => void;
@@ -1421,6 +1481,9 @@ export declare class SessionManager {
     getSessionName(): string | undefined;
     isSessionStarred(): boolean;
     setSessionStarred(starred: boolean): Promise<boolean>;
+    setSessionStarredForPicker(session: SessionInfo, starred: boolean): Promise<void>;
+    /** Update only a picker candidate's metadata, without opening a runtime or publishing a resume breadcrumb. */
+    static setSessionStarredForPicker(session: SessionInfo, starred: boolean, explicitSessionDir?: string): Promise<void>;
     setSessionName(name: string, source?: "auto" | "user"): Promise<boolean>;
     _persist(entry: SessionEntry): void;
     /** Append a configured fallback chain as child of current leaf, then advance leaf. Returns entry id. */

package/dist/types/session/session-work-lease.d.ts

@@ -0,0 +1,14 @@
+/**
+ * One authoritative, reference-counted lease for work that still needs a
+ * session host. Each admitted work state owns one handle and releases that
+ * handle at its terminal boundary; the host only observes whether any handle
+ * remains held.
+ */
+export interface SessionWorkLeaseHandle {
+    release(): void;
+}
+export interface SessionWorkLease {
+    acquire(): SessionWorkLeaseHandle;
+    isHeld(): boolean;
+}
+export declare function createSessionWorkLease(): SessionWorkLease;

package/dist/types/setup/model-onboarding-guidance.d.ts

@@ -1,4 +1,4 @@
-export declare const MODEL_ONBOARDING_API_PROVIDER_COMMAND = "/provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <model>";
+export declare const MODEL_ONBOARDING_API_PROVIDER_COMMAND = "/provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> (--model <model> | --discover)";
 export declare const MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND = "/provider add --preset <id>";
 export declare const MODEL_ONBOARDING_SETUP_COMMAND = "gjc setup provider";
 export declare const MODEL_ONBOARDING_OAUTH_COMMAND = "/provider login [provider-id] or /login [provider-id]";

package/dist/types/setup/provider-onboarding.d.ts

@@ -1,3 +1,4 @@
+import { type AuthStorage } from "@gajae-code/ai/core";
 import { type ModelsConfig, type ProviderDiscovery } from "../config/models-config-schema";
 export type ProviderCompatibility = "openai" | "anthropic";
 export type ProviderSetupApi = "openai-responses" | "openai-completions" | "anthropic-messages";
@@ -11,6 +12,37 @@ export interface ProviderSetupInput {
     models?: string[];
     modelsPath?: string;
     force?: boolean;
+    /**
+     * Opt into live OpenAI `/v1/models` discovery for an OpenAI-compatible
+     * custom provider. Manual `--model` ids may be omitted when set; the
+     * runtime auto-discovers the catalog on refresh and merges it without
+     * duplicates.
+     *
+     * When no manual models are given, setup probes the endpoint before
+     * writing config so an unreachable endpoint, rejected credential, or
+     * empty catalog fails the setup loudly instead of writing a provider
+     * that can never serve a model. There is deliberately no skip flag: the
+     * pre-write probe is the enforcement point, and the wizard's
+     * interactive probe is a preview only (inputs may have changed since).
+     */
+    discover?: boolean;
+    /** Probe override for tests; defaults to the live endpoint probe. */
+    probeDiscovery?: (input: ProviderDiscoveryProbeInput) => Promise<ProviderDiscoveryProbeResult>;
+    /**
+     * Cancel discovery and persistence until the atomic config rename is
+     * invoked. Later cancellation does not undo a committed provider.
+     * Combined with the shared deadline inside the probe; callers that omit
+     * it get deadline-only probe behavior.
+     */
+    discoverySignal?: AbortSignal;
+    /**
+     * Live credential authority for literal-key persistence. Interactive
+     * callers pass the active session registry's AuthStorage so the
+     * subsequent targeted online refresh authenticates from the same
+     * authority that stored the key. When omitted, onboarding falls back
+     * to a short-lived store at the agent DB path (headless/CLI behavior).
+     */
+    authStorage?: ProviderSetupCredentialStore;
 }
 export interface ProviderSetupResult {
     providerId: string;
@@ -21,11 +53,18 @@ export interface ProviderSetupResult {
     modelsPath: string;
     redactedApiKey: string;
     credentialSource: "literal" | "env";
+    /** True when the provider persists a `discovery:` block (live catalog). */
+    discoveryEnabled: boolean;
+    /** The persisted discovery type, when any (e.g. `openai-models-list`). */
+    discoveryType?: string;
     preset?: string;
     presetName?: string;
 }
 type ProviderConfig = NonNullable<NonNullable<ModelsConfig["providers"]>[string]>;
 type ProviderCompatConfig = NonNullable<ProviderConfig["compat"]>;
+type ProviderSetupCredentialStore = Pick<AuthStorage, "set" | "remove" | "exportSnapshot"> & {
+    peekApiKey?: (provider: string) => Promise<string | undefined>;
+};
 interface ProviderPreset {
     id: string;
     aliases: readonly string[];
@@ -54,8 +93,49 @@ export declare function parseProviderCompatibility(value: string): ProviderCompa
 export declare function findProviderPreset(value: string | undefined): ProviderPreset | undefined;
 export declare function formatProviderPresetList(): string;
 export declare function parseModelList(values: readonly string[]): string[];
-export declare function redactSecret(secret: string): string;
+export declare function redactSecret(_secret: string): string;
 export declare function validateModelApi(modelApi: Readonly<Record<string, string>> | undefined, models: readonly string[], presetId: string): void;
 export declare function addApiCompatibleProvider(input: ProviderSetupInput): Promise<ProviderSetupResult>;
+export interface ProviderDiscoveryProbeInput {
+    baseUrl: string;
+    apiKeyEnv?: string;
+    apiKey?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface ProviderDiscoveryProbeResult {
+    models: string[];
+    endpoint: string;
+}
+/**
+ * Probe an OpenAI-compatible `/v1/models` endpoint and return the sorted
+ * model ids. Used by the Add-custom-provider wizard so gateway catalogs
+ * (LiteLLM and friends) do not need manual transcription.
+ *
+ * Credential handling: an `apiKeyEnv` name resolves through the trusted
+ * credential env only (never `cwd/.env`); a literal `apiKey` is used as-is.
+ * Errors name the redacted endpoint only — the key material never appears
+ * in messages, and callers must not log the request headers.
+ */
+export declare function probeOpenAIModelsList(input: ProviderDiscoveryProbeInput): Promise<ProviderDiscoveryProbeResult>;
+export interface DiscoveryCatalogRefresher {
+    refresh(mode: "offline" | "online" | "online-if-uncached", credentialSessionId?: string): Promise<void>;
+    refreshProvider(providerId: string, strategy?: "offline" | "online" | "online-if-uncached", credentialSessionId?: string): Promise<void>;
+    getProviderDiscoveryState(providerId: string): {
+        status: string;
+        error?: string;
+    } | undefined;
+}
+/**
+ * Reload static config offline, then refresh only the newly added discovery
+ * provider online so freshly requested live catalogs are selectable
+ * immediately (including alongside manual models). Preset-managed
+ * discovery is excluded by callers: presets resolve lazily at runtime.
+ * Returns a recovery hint instead of reporting unconditional success when
+ * the live catalog stays unavailable: the config is saved and valid, but
+ * the user needs to know the catalog did not populate and how to recover
+ * (wait for the next refresh, or re-add with explicit `--model` ids).
+ */
+export declare function reloadAndRefreshDiscoveryCatalog(registry: DiscoveryCatalogRefresher, providerId: string, credentialSessionId?: string): Promise<string | null>;
 export declare function formatProviderSetupResult(result: ProviderSetupResult): string;
 export {};

package/dist/types/task/types.d.ts

@@ -514,6 +514,8 @@ export interface AgentProgress {
     }>;
     recentOutput: string[];
     toolCount: number;
+    /** Epoch ms of the latest event observed from this subagent (any agent event). */
+    lastActivityMs?: number;
     /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
     tokens: number;
     /**

package/dist/types/tools/bash-interactive.d.ts

@@ -30,6 +30,7 @@ export declare function runInteractiveBashPty(ui: NonNullable<AgentToolContext["
     timeoutMs: number;
     signal?: AbortSignal;
     env?: Record<string, string>;
+    unsetEnv?: string[];
     artifactPath?: string;
     artifactId?: string;
     artifactPublisher?: TerminalArtifactPublisher;

package/dist/types/tools/bash.d.ts

@@ -8,25 +8,40 @@ import { type Theme } from "../modes/theme/theme";
 import { type SdkSpawnArgs } from "../sdk/cli/master-cli";
 import type { ToolSession } from ".";
 import { type OutputMeta } from "./output-meta";
+export { STEER_FOLD_GRACE_MS, steerFoldReasonLine } from "./steer-fold";
 export declare const BASH_DEFAULT_PREVIEW_LINES = 10;
-/**
- * A user steer folds a running foreground bash call only after it has been
- * running at least this long. Shorter commands finish normally and the steer is
- * consumed at the ordinary tool boundary, so a quick `git status` never turns
- * into a background job plus a wake-up turn.
- */
-export declare const STEER_FOLD_GRACE_MS = 2000;
-/** Model-facing line appended to a steer-folded background-start result. */
-export declare function steerFoldReasonLine(jobId: string): string;
 export type BashOriginalArtifactSaveResult = BashArtifactSaveResult;
 export declare function suffixPrefixOverlap(source: string, target: string): number;
 export declare function saveBashOriginalArtifactForTests(session: ToolSession, originalText: string, onResult?: (result: BashOriginalArtifactSaveResult) => void): Promise<string | undefined>;
+/**
+ * Model-declared activity metadata for the browser-backend routing contract
+ * (`browser.backend: aside`). When that contract routes a browser task through
+ * Bash, it requires the call to declare the activity structurally so consumers
+ * can project it without parsing the command text. The declaration is
+ * model-declared and schema-validated only: nothing here verifies that the
+ * command actually invokes Aside, and the executor never inspects `command`.
+ */
+export type BashActivityProvider = "aside";
+export type BashActivityMode = "repl" | "exec";
+export interface BashActivityDeclaration {
+    kind: "browser";
+    provider: BashActivityProvider;
+    mode: BashActivityMode;
+}
 declare const bashSchemaBase: z.ZodObject<{
     command: z.ZodString;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     cwd: z.ZodOptional<z.ZodString>;
     pty: z.ZodOptional<z.ZodBoolean>;
+    activity: z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"browser">;
+        provider: z.ZodLiteral<"aside">;
+        mode: z.ZodEnum<{
+            exec: "exec";
+            repl: "repl";
+        }>;
+    }, z.core.$strict>>>;
 }, z.core.$strip>;
 declare const bashSchemaWithAsync: z.ZodObject<{
     command: z.ZodString;
@@ -34,6 +49,14 @@ declare const bashSchemaWithAsync: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     cwd: z.ZodOptional<z.ZodString>;
     pty: z.ZodOptional<z.ZodBoolean>;
+    activity: z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"browser">;
+        provider: z.ZodLiteral<"aside">;
+        mode: z.ZodEnum<{
+            exec: "exec";
+            repl: "repl";
+        }>;
+    }, z.core.$strict>>>;
     async: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type BashToolSchema = typeof bashSchemaBase | typeof bashSchemaWithAsync;
@@ -44,6 +67,8 @@ export interface BashToolInput {
     cwd?: string;
     async?: boolean;
     pty?: boolean;
+    /** Accepted activity declaration, mirrored into {@link BashToolDetails.activity}. */
+    activity?: BashActivityDeclaration;
 }
 export interface BashToolDetails {
     meta?: OutputMeta;
@@ -52,6 +77,8 @@ export interface BashToolDetails {
     terminalId?: string;
     /** Why the foreground wait was folded, when this result is a background-start after a fold. */
     foldReason?: FoldReason;
+    /** The accepted model-declared activity declaration, when the call carried one. */
+    activity?: BashActivityDeclaration;
     async?: {
         state: "running" | "completed" | "failed";
         jobId: string;
@@ -104,7 +131,7 @@ export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetai
         label: string;
         commandCwd: string;
     }>;
-    execute(toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty, }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
+    execute(toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty, activity, }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
 }
 export interface BashRenderArgs {
     command?: string;
@@ -173,4 +200,3 @@ export declare const bashToolRenderer: {
     mergeCallAndResult: boolean;
     inline: boolean;
 };
-export {};

package/dist/types/tools/fetch.d.ts

@@ -4,8 +4,9 @@ import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from "../sdk";
+import type { AgentStorage } from "../session/agent-storage";
 import { type TruncationDirection } from "../session/streaming-output";
-import type { RenderResult } from "../web/scrapers/types";
+import { type RenderResult } from "../web/scrapers/types";
 import { type OutputMeta } from "./output-meta";
 export declare function isReadableUrlPath(value: string): boolean;
 export interface ParsedReadUrlTarget {
@@ -27,6 +28,14 @@ interface FetchImagePayload {
 type FetchRenderResult = RenderResult & {
     image?: FetchImagePayload;
 };
+/**
+ * Try all special handlers
+ */
+declare function handleSpecialUrls(url: string, timeout: number, signal: AbortSignal | undefined, storage: AgentStorage | null): Promise<FetchRenderResult | null>;
+/** Test-only seam for verifying lazy special-handler loading and dispatch. */
+export declare const fetchSpecialHandlerTestHooks: {
+    dispatch: typeof handleSpecialUrls;
+};
 export declare function tryInsaneFallback(args: {
     url: string;
     finalUrl: string;

package/dist/types/tools/job.d.ts

@@ -15,7 +15,7 @@ type JobParams = z.infer<typeof jobSchema>;
 interface JobSnapshot {
     id: string;
     type: "bash" | "task";
-    status: "running" | "completed" | "failed" | "cancelled";
+    status: "running" | "paused" | "completed" | "failed" | "cancelled";
     label: string;
     durationMs: number;
     /** Present when the job was folded out of a foreground wait. */

package/dist/types/tools/steer-fold.d.ts

@@ -0,0 +1,31 @@
+import type { FoldReason } from "../async/job-manager";
+import type { ToolSession } from ".";
+/** A short foreground wait stays in the foreground even when a steer is admitted. */
+export declare const STEER_FOLD_GRACE_MS = 2000;
+/** Model-facing line appended to a steer-folded background-start result. */
+export declare function steerFoldReasonLine(jobId: string): string;
+/** Model-facing cause clause for a fold, keyed by the recorded {@link FoldReason}. */
+export declare function foldReasonClause(reason: FoldReason): string;
+/** Model-facing line used when the `job` tool's own wait is folded; states the real trigger. */
+export declare function foldAwaitReasonLine(folded: ReadonlyMap<string, FoldReason>): string;
+type SteerFoldSession = Pick<ToolSession, "settings" | "waitForUserSteering" | "requestForegroundBashBackground">;
+/** The session hooks a steer fold needs, resolved once so callers never re-read and non-null-assert them. */
+interface SteerFoldHooks {
+    waitForSteer: NonNullable<ToolSession["waitForUserSteering"]>;
+    requestFold: NonNullable<ToolSession["requestForegroundBashBackground"]>;
+}
+/**
+ * Fold on the first user steer that ARRIVES after the wait has run for
+ * {@link STEER_FOLD_GRACE_MS} since `startedAt`. A steer already queued when
+ * the wait starts, or one that arrives inside the grace window, never folds:
+ * the wait finishes normally and that steer is consumed at the ordinary tool
+ * boundary. The watcher keeps observing so a later qualifying steer still
+ * folds, and re-checks the gate at that moment so a `busyPromptMode` change
+ * during the wait is honored. `requestFold` receives the session's resolved
+ * fold request so the caller targets its own adapter without re-reading the
+ * optional session hook.
+ * Returns a stop function; call it when the wait settles. No-op when steer
+ * folding is gated off at start.
+ */
+export declare function watchSteerForFold(session: SteerFoldSession, startedAt: number, requestFold: (fold: SteerFoldHooks["requestFold"]) => Promise<unknown>, jobId?: string): () => void;
+export {};

package/dist/types/tools/subagent.d.ts

@@ -80,6 +80,10 @@ export interface SubagentLiveProgress {
     recentOutputSummary?: {
         lineCount: number;
     };
+    toolCount?: number;
+    contextTokens?: number;
+    contextWindow?: number;
+    lastActivityMs?: number;
     fastMode?: boolean;
     retryState?: {
         attempt: number;
@@ -165,10 +169,13 @@ export declare function capCodePointsAndBytes(text: string, maxCodePoints: numbe
  * unsafe.
  *
  * Time-derived fields are intentionally excluded so the panel does not churn while
- * idle: raw durations (`durationMs`), current-tool elapsed (`currentToolStartMs`),
+ * idle (the child's last-event timestamp is included; it moves only on real
+ * activity): raw durations (`durationMs`), current-tool elapsed (`currentToolStartMs`),
  * and retry countdowns (`retryState.startedAtMs`) are omitted. Idle duration and
  * countdown ticking is sacrificed by design; every real transition still changes
  * the signature.
  */
+/** Shared cadence for await progress refreshes and rendered last-activity age. */
+export declare const SUBAGENT_ACTIVITY_BUCKET_MS = 5000;
 export declare function subagentAwaitRenderedStateSignature(subagents: readonly SubagentSnapshot[], receipt?: Pick<SubagentToolDetails, "awaitOutcome" | "interrupted">): string;
 export {};

package/dist/types/utils/git.d.ts

@@ -162,8 +162,12 @@ export declare const status: ((cwd: string, options?: StatusOptions) => Promise<
     parse: typeof parseStatusPorcelain;
 };
 export declare const stage: {
-    /** Stage files. Empty array stages all (`git add -A`). */
-    files(cwd: string, files?: readonly string[], signal?: AbortSignal): Promise<void>;
+    /**
+     * Stage files. Empty array stages all (`git add -A`). Accepts a bare signal or
+     * `{ env, signal }`; `env` exists so a caller can stage into an isolated
+     * `GIT_INDEX_FILE` instead of the repository's real index.
+     */
+    files(cwd: string, files?: readonly string[], options?: AbortSignal | Pick<CommandOptions, "env" | "signal">): Promise<void>;
     /** Selectively stage hunks from the provided diff or the current working tree diff. */
     hunks(cwd: string, selections: HunkSelection[], options?: StageHunksOptions): Promise<void>;
     /** Unstage files. Empty array unstages all (`git reset`). */
@@ -181,6 +185,17 @@ export declare function fetch(cwd: string, remote: string, source: string, targe
 export declare function readTree(cwd: string, treeish: string, options?: Pick<CommandOptions, "env" | "signal">): Promise<void>;
 /** Write the current index as a tree and return its object id. */
 export declare function writeTree(cwd: string, options?: Pick<CommandOptions, "env" | "signal">): Promise<string>;
+export interface CommitTreeOptions {
+    readonly env?: Record<string, string | undefined>;
+    readonly parents?: readonly string[];
+    readonly signal?: AbortSignal;
+}
+/**
+ * Create a commit object from an existing tree and return its SHA. Plumbing:
+ * unlike `commit` this touches neither the index nor any ref, and runs no
+ * `pre-commit`/`commit-msg` hook.
+ */
+export declare function commitTree(cwd: string, tree: string, message: string, options?: CommitTreeOptions): Promise<string>;
 /** Run `git show` on a revision. */
 export declare const show: ((cwd: string, revision: string, options?: {
     format?: string;
@@ -241,6 +256,17 @@ export declare const ref: {
     exists(cwd: string, refName: string, signal?: AbortSignal): Promise<boolean>;
     /** Resolve a ref to its commit SHA. */
     resolve(cwd: string, refName: string, signal?: AbortSignal): Promise<string | null>;
+    /**
+     * Move a ref to `newValue`, but only while it still holds `expectedOldValue`
+     * (the empty string asserts the ref does not exist yet). Git verifies the old
+     * value and writes the new one under its own ref lock, so this is an atomic
+     * compare-and-swap: a concurrent writer that moved the ref first makes this
+     * throw instead of silently clobbering their commit.
+     */
+    update(cwd: string, refName: string, newValue: string, expectedOldValue: string, options?: {
+        reason?: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
     /** Tags pointing at a ref. */
     tags(cwd: string, refName?: string, signal?: AbortSignal): Promise<string[]>;
 };

package/dist/types/utils/mupdf-embedded.d.ts

@@ -0,0 +1,2 @@
+export declare const embeddedMuPdfWasm: string | undefined;
+export declare const embeddedMuPdfModule: string | undefined;

package/dist/types/utils/mupdf.d.ts

@@ -0,0 +1,4 @@
+export declare let mupdfAssetMapping: string;
+export declare function prepareMuPdf(): Promise<void>;
+export declare function withMuPdfDiagnostic(error: unknown): Error;
+export declare function sanitizeMuPdfDiagnostic(message: string): string;

package/dist/types/utils/session-title-generation.d.ts

@@ -0,0 +1,6 @@
+/** Start a new regeneration and invalidate every older completion. */
+export declare function beginSessionTitleGeneration(owner: object): number;
+/** Invalidate pending regeneration after a newer session mutation is accepted. */
+export declare function invalidateSessionTitleGeneration(owner: object): void;
+/** Return whether a regeneration still owns the latest generation lease. */
+export declare function isSessionTitleGenerationCurrent(owner: object, generation: number): boolean;

package/dist/types/utils/title-generator.d.ts

@@ -1,10 +1,19 @@
+import type { AgentMessage } from "@gajae-code/agent-core";
 import { type Api, type Model } from "@gajae-code/ai/core";
 import type { ModelRegistry } from "../config/model-registry";
 import type { Settings } from "../config/settings";
 /**
- * Generate a title for a session based on the first user message.
+ * Build a bounded conversation digest for title regeneration. Regeneration
+ * reads several messages so a throwaway first prompt can be corrected, while
+ * the automatic first-message path intentionally uses only its initial input.
+ */
+export declare function buildConversationTitleInput(messages: readonly AgentMessage[]): string | undefined;
+/**
+ * Generate a title for a session based on the provided user-message input.
+ * Automatic titles pass the first user message; regeneration passes a bounded
+ * conversation digest.
  *
- * @param firstMessage The first user message
+ * @param firstMessage The first user message or bounded conversation digest
  * @param registry Model registry
  * @param settings Settings used to resolve the smol role
  * @param sessionId Optional session id for sticky API key selection

package/dist/types/web/scrapers/types.d.ts

@@ -34,7 +34,10 @@ export interface LoadPageOptions {
 }
 export interface LoadPageResult {
     content: string;
+    /** The bounded response bytes retained for binary classification/conversion. */
+    buffer?: Uint8Array;
     contentType: string;
+    contentDisposition?: string;
     finalUrl: string;
     ok: boolean;
     status?: number;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.17.2",
+	"version": "0.17.5",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -29,8 +29,8 @@
 		"가재씨": "bin/gajaessi.js"
 	},
 	"scripts": {
-		"build": "bun scripts/build-binary.ts",
-		"check": "biome check . && bun run check:types",
+		"build": "bun run verify:markit-vendor && bun scripts/build-binary.ts",
+		"check": "bun run verify:markit-vendor && biome check . && bun run check:types",
 		"check:runtime": "bun run generate-hotkeys-docs --check && bun run verify:sdk-canonicalization",
 		"check:types": "tsc -p tsconfig.json --noEmit",
 		"check:autorouting-map": "bun scripts/check-autorouting-tier-map.ts",
@@ -49,32 +49,40 @@
 		"generate-template": "bun scripts/generate-template.ts",
 		"install:defaults": "bun src/cli.ts setup defaults",
 		"verify:insane-vendor": "bun scripts/verify-insane-vendor.ts",
+		"verify:markit-vendor": "bun scripts/vendor-markit.ts --check",
 		"verify:sdk-canonicalization": "bun scripts/verify-gjc-sdk-canonicalization.ts",
 		"check:sdk-closure": "bun ../../scripts/telegram-daemon-generation-guard.ts --validate-current-tree && bun test ../../scripts/telegram-daemon-generation-guard.test.ts && bun scripts/generate-sdk-operation-inventory.ts --check && bun scripts/generate-sdk-adapter-parity-manifest.ts --check && GJC_MANIFEST_RECEIPT_CONCURRENCY=8 bun scripts/run-test-manifest.ts test/manifests/sdk-adapter-parity-v1.json && bun scripts/generate-telegram-baseline-manifest.ts --check && bun scripts/run-test-manifest.ts test/manifests/telegram-baseline-v1.json && bun test test/sdk-downgrade-rollback.test.ts test/sdk-downgrade-unknown-version.test.ts && bun scripts/verify-gjc-sdk-canonicalization.ts --self-test && bun scripts/verify-gjc-sdk-canonicalization.ts && bun scripts/verify-gjc-sdk-rename.ts"
 	},
 	"dependencies": {
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@babel/parser": "^7.29.3",
-		"@gajae-code/agent-core": "0.17.2",
-		"@gajae-code/ai": "0.17.2",
-		"@gajae-code/natives": "0.17.2",
-		"@gajae-code/stats": "0.17.2",
-		"@gajae-code/tui": "0.17.2",
-		"@gajae-code/utils": "0.17.2",
 		"@mozilla/readability": "^0.6.0",
+		"@gajae-code/stats": "0.17.5",
+		"@gajae-code/agent-core": "0.17.5",
+		"@gajae-code/ai": "0.17.5",
+		"@gajae-code/natives": "0.17.5",
+		"@gajae-code/tui": "0.17.5",
+		"@gajae-code/utils": "0.17.5",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
 		"chalk": "^5.6.2",
+		"commander": "14.0.3",
 		"diff": "^9.0.0",
+		"exifr": "7.1.3",
+		"fast-xml-parser": "5.10.1",
 		"fflate": "0.8.2",
 		"handlebars": "^4.7.9",
 		"jsonc-parser": "3.3.1",
+		"jszip": "3.10.1",
 		"linkedom": "^0.18.12",
 		"lru-cache": "11.3.6",
+		"mammoth": "1.12.0",
 		"marked": "18.0.6",
-		"markit-ai": "0.5.3",
+		"mupdf": "1.28.0",
+		"music-metadata": "11.14.0",
 		"puppeteer-core": "^24.42.0",
+		"rss-parser": "3.13.0",
 		"turndown": "7.2.4",
 		"turndown-plugin-gfm": "1.0.2",
 		"zod": "4.4.3"

package/scripts/build-binary.ts

@@ -3,6 +3,7 @@
 import * as path from "node:path";
 import { signMacOSBinary } from "../../../scripts/macos-code-signing";
 import { buildDevCompileArgs } from "./compile-args";
+import { generateMuPdfAsset, resetMuPdfAsset } from "./embed-mupdf";
 
 const packageDir = path.join(import.meta.dir, "..");
 const outputPath = path.join(packageDir, "dist", "gjc");
@@ -31,10 +32,11 @@ async function stageWorkspaceNativeAddons(): Promise<void> {
 }
 
 async function main(): Promise<void> {
-	await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--generate"]);
 	try {
-		await runCommand(["bun", "--cwd=../natives", "run", "embed:native"]);
+		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--generate"]);
 		try {
+			await generateMuPdfAsset();
+			await runCommand(["bun", "--cwd=../natives", "run", "embed:native"]);
 			const buildEnv = shouldAdhocSignDarwinBinary() ? { ...Bun.env, BUN_NO_CODESIGN_MACHO_BINARY: "1" } : Bun.env;
 			await runCommand(buildDevCompileArgs(), buildEnv);
 
@@ -47,7 +49,11 @@ async function main(): Promise<void> {
 			await runCommand(["bun", "--cwd=../natives", "run", "embed:native", "--reset"]);
 		}
 	} finally {
-		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--reset"]);
+		try {
+			await resetMuPdfAsset();
+		} finally {
+			await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--reset"]);
+		}
 	}
 }