@gajae-code/coding-agent 0.5.1 → 0.5.3

package/dist/types/session/streaming-output.d.ts

@@ -2,6 +2,7 @@ import type { AgentToolUpdateCallback } from "@gajae-code/agent-core";
 export declare const DEFAULT_MAX_LINES = 3000;
 export declare const DEFAULT_MAX_BYTES: number;
 export declare const DEFAULT_MAX_COLUMN = 1024;
+export declare const DEFAULT_ARTIFACT_MAX_BYTES: number;
 export interface OutputSummary {
     output: string;
     truncated: boolean;
@@ -19,6 +20,8 @@ export interface OutputSummary {
     columnTruncatedLines?: number;
     /** Artifact ID for internal URL access (artifact://<id>) when truncated */
     artifactId?: string;
+    /** Bytes omitted from artifact storage after the artifact hard cap was reached. */
+    artifactTruncatedBytes?: number;
 }
 export interface OutputSinkOptions {
     artifactPath?: string;
@@ -38,6 +41,8 @@ export interface OutputSinkOptions {
      * writes still respect the budget. Default 0 = no per-line cap.
      */
     maxColumns?: number;
+    /** Hard cap for artifact writes/pending replay. Default DEFAULT_ARTIFACT_MAX_BYTES. */
+    artifactMaxBytes?: number;
     onChunk?: (chunk: string) => void;
     /** Minimum ms between onChunk calls. 0 = every chunk (default). */
     chunkThrottleMs?: number;

package/dist/types/setup/credential-import.d.ts

@@ -0,0 +1,79 @@
+import type { AuthCredential } from "@gajae-code/ai";
+/** gjc provider ids that external credentials map onto. */
+export type ExternalProvider = "anthropic" | "openai-codex";
+/** Where a discovered credential came from. */
+export type CredentialOrigin = "claude-code-file" | "claude-code-keychain" | "codex-file";
+/** Human labels for providers, used in redacted summaries. */
+export declare const EXTERNAL_PROVIDER_LABELS: Record<ExternalProvider, string>;
+/** A credential that can be safely imported into gjc's store. */
+export interface ImportableCredential {
+    provider: ExternalProvider;
+    origin: CredentialOrigin;
+    /** Redacted, human-readable description of where this came from. */
+    source: string;
+    kind: AuthCredential["type"];
+    identity?: {
+        email?: string;
+        accountId?: string;
+    };
+    /** Epoch-ms expiry for OAuth credentials, when known. */
+    expiresAt?: number;
+    /** Redacted access token / API key — safe to display. */
+    redactedToken: string;
+    /** Opaque credential payload. Never include this in any summary output. */
+    credential: AuthCredential;
+}
+/** A source that was found but could not be imported. */
+export interface SkippedCredential {
+    origin: CredentialOrigin;
+    source: string;
+    reason: string;
+}
+/** Ambient environment-backed auth that is already usable without import. */
+export interface EnvironmentCredentialHint {
+    provider: ExternalProvider;
+    variable: string;
+    redactedValue: string;
+}
+export interface CredentialDiscoveryResult {
+    importable: ImportableCredential[];
+    skipped: SkippedCredential[];
+    environment: EnvironmentCredentialHint[];
+}
+export interface DiscoveryOptions {
+    /** Override the home directory (defaults to `os.homedir()`). */
+    homeDir?: string;
+    /** Override the environment (defaults to `process.env`). */
+    env?: Record<string, string | undefined>;
+    /** Override the platform (defaults to `process.platform`). */
+    platform?: NodeJS.Platform;
+    /**
+     * Reader for the macOS Keychain `Claude Code-credentials` entry. Defaults to
+     * shelling out to `security`; injected in tests. Returns the raw JSON string,
+     * or `null` when no entry exists.
+     */
+    readClaudeKeychain?: () => Promise<string | null>;
+}
+export type CredentialUpserter = (provider: string, credential: AuthCredential) => unknown | Promise<unknown>;
+export interface ImportSummary {
+    imported: ImportableCredential[];
+    failed: Array<{
+        credential: ImportableCredential;
+        error: string;
+    }>;
+}
+/**
+ * Discover Claude Code and Codex CLI credentials across files, the macOS
+ * Keychain, and environment variables. Never throws for individual unreadable or
+ * malformed sources — those land in {@link CredentialDiscoveryResult.skipped}.
+ */
+export declare function discoverExternalCredentials(options?: DiscoveryOptions): Promise<CredentialDiscoveryResult>;
+/** Redacted one-line summary of an importable credential. Never includes secrets. */
+export declare function formatCredentialSummary(credential: ImportableCredential): string;
+/** Redacted summary lines for an entire discovery result. Never includes secrets. */
+export declare function formatDiscoverySummary(result: CredentialDiscoveryResult): string[];
+/**
+ * Persist discovered credentials via `upsert`. Each credential is imported
+ * independently; a failure on one is recorded without aborting the rest.
+ */
+export declare function importCredentials(credentials: readonly ImportableCredential[], upsert: CredentialUpserter): Promise<ImportSummary>;

package/dist/types/slash-commands/helpers/fast-status-report.d.ts

@@ -0,0 +1,76 @@
+import type { Model } from "@gajae-code/ai";
+/**
+ * A single line in the `/fast status` report: a labelled model and whether fast
+ * mode is effective for it. The `fast` flag is resolved by the caller
+ * (`buildFastStatusReport`) so each row can use the correct service tier — the
+ * main session tier for the current model / `modelRoles` roles, or the subagent
+ * tier (`task.serviceTier`) for `task.agentModelOverrides` roles.
+ */
+export interface FastStatusRow {
+    /** Display label, e.g. "현재 모델", "DEFAULT", "EXECUTOR". */
+    label: string;
+    /** Resolved model for this row, if any. */
+    model?: Model;
+    /** Whether fast mode is effective for this row's model. */
+    fast: boolean;
+}
+export interface FormatFastStatusReportArgs {
+    rows: FastStatusRow[];
+    /** The active theme's fast icon token (`theme.icon.fast`). */
+    iconFast: string;
+    /** Optional decorator for inactive ("off") text, e.g. theme dim in the TUI. */
+    formatInactive?: (text: string) => string;
+}
+/** Title line of the `/fast status` report. */
+export declare const FAST_STATUS_TITLE = "Fast \uBAA8\uB4DC \uC0C1\uD0DC";
+/** The inactive marker shown for rows where fast mode does not apply. */
+export declare const FAST_STATUS_OFF = "off";
+/**
+ * Format a multiline `/fast status` report. Pure and shared by the CLI
+ * (`handle`) and TUI (`handleTui`) command branches so the two never drift.
+ * Each row's fast/off state is decided by the caller (see
+ * {@link buildFastStatusReport}) so per-row service-tier differences are honored.
+ */
+export declare function formatFastStatusReport(args: FormatFastStatusReportArgs): string;
+/** Minimal session surface needed to build the `/fast status` report. */
+export interface FastStatusSessionLike {
+    readonly model?: Model;
+    /** Fast predicate against the main session tier (current model + `modelRoles`). */
+    isFastForProvider(provider?: string): boolean;
+    /** Fast predicate against the effective subagent tier (`task.agentModelOverrides` roles). */
+    isFastForSubagentProvider(provider?: string): boolean;
+    resolveRoleModelWithThinking(role: string): {
+        model?: Model;
+    };
+}
+/** A role to enumerate in the report, with the tier source its subagent runs under. */
+export interface FastStatusRoleTarget {
+    id: string;
+    label: string;
+    /**
+     * True for `task.agentModelOverrides` roles (executor/architect/planner/critic)
+     * that run under `task.serviceTier`; false for `modelRoles` roles (default)
+     * that run under the main session tier.
+     */
+    isSubagentRole: boolean;
+}
+export interface BuildFastStatusReportArgs {
+    session: FastStatusSessionLike;
+    /** Role targets to enumerate, in display order. */
+    roleTargets: ReadonlyArray<FastStatusRoleTarget>;
+    /** The active theme's fast icon token (`theme.icon.fast`). */
+    iconFast: string;
+    /** Optional decorator for inactive ("off") text, e.g. theme dim in the TUI. */
+    formatInactive?: (text: string) => string;
+}
+/**
+ * Build the `/fast status` report from a live session: the active/current model
+ * followed by each assigned role (subagent) model. Unassigned roles are skipped
+ * so the report mirrors the `/model` selector, which only badges assigned roles.
+ *
+ * Subagent roles (`task.agentModelOverrides`) are evaluated against the
+ * effective subagent tier (`task.serviceTier`), while the current model and
+ * `modelRoles` roles use the main session tier — matching where each model
+ * actually runs.
+ */
+export declare function buildFastStatusReport(args: BuildFastStatusReportArgs): string;

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

@@ -105,6 +105,7 @@ interface FinalizeSubprocessOutputResult {
 export declare const SUBAGENT_WARNING_NULL_YIELD = "SYSTEM WARNING: Subagent called yield with null data.";
 export declare const SUBAGENT_WARNING_MISSING_YIELD = "SYSTEM WARNING: Subagent exited without calling yield tool after 3 reminders.";
 export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult;
+export declare function createSubagentSettings(baseSettings: Settings): Settings;
 /**
  * Run a single agent in-process.
  */

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

@@ -11,7 +11,7 @@ export declare function renderCall(args: TaskParams, _options: RenderResultOptio
  * `subagent` await panel. Reuses the internal task-progress renderer so the
  * await panel stays at parity with the inline task panel.
  */
-export declare function renderSubagentLiveProgress(progress: AgentProgress, expanded: boolean, theme: Theme, spinnerFrame?: number): string[];
+export declare function renderSubagentLiveProgress(progress: AgentProgress, expanded: boolean, theme: Theme, spinnerFrame?: number, staticTime?: boolean): string[];
 /**
  * Render the tool result.
  */

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

@@ -6,6 +6,7 @@ import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
 import { type OutputMeta } from "./output-meta";
 export declare const BASH_DEFAULT_PREVIEW_LINES = 10;
+export declare function saveBashOriginalArtifactForTests(session: ToolSession, originalText: string): Promise<string | undefined>;
 declare const bashSchemaBase: z.ZodObject<{
     command: z.ZodString;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;

package/dist/types/tools/browser/tab-supervisor.d.ts

@@ -26,6 +26,8 @@ export interface TabSession {
     pending: Map<string, PendingRun>;
     dialogPolicy?: DialogPolicy;
     kindTag: BrowserKindTag;
+    /** Session that acquired this tab; used for session-scoped teardown (F13). */
+    ownerId?: string;
 }
 export interface AcquireTabOptions {
     url?: string;
@@ -39,6 +41,8 @@ export interface AcquireTabOptions {
     signal?: AbortSignal;
     timeoutMs: number;
     dialogs?: DialogPolicy;
+    /** Owning session id so dispose can release only this session's tabs (F13). */
+    ownerId?: string;
 }
 export interface AcquireTabResult {
     tab: TabSession;
@@ -58,6 +62,11 @@ export declare function acquireTab(name: string, browser: BrowserHandle, opts: A
 export declare function runInTab(name: string, opts: RunInTabOptions): Promise<RunResultOk>;
 export declare function releaseTab(name: string, opts?: ReleaseTabOptions): Promise<boolean>;
 export declare function releaseAllTabs(opts?: ReleaseTabOptions): Promise<number>;
+/**
+ * Release only the tabs owned by `ownerId` (F13 session-scoped teardown). Tabs acquired
+ * by other sessions (or with no owner) are left untouched. No-op for a null/empty owner.
+ */
+export declare function releaseTabsForOwner(ownerId: string | null | undefined, opts?: ReleaseTabOptions): Promise<number>;
 export declare function dropHeadlessTabs(): Promise<void>;
 export declare function initializeTabWorkerForTest(worker: WorkerHandle, payload: WorkerInitPayload, timeoutMs: number): Promise<ReadyInfo>;
 export {};

package/dist/types/tools/sqlite-reader.d.ts

@@ -60,9 +60,10 @@ export declare function getRowByKey(db: Database, table: string, pk: {
     type?: string;
 }, key: string): Record<string, unknown> | null;
 export declare function getRowByRowId(db: Database, table: string, key: string): Record<string, unknown> | null;
-export declare function executeReadQuery(db: Database, sql: string): {
+export declare function executeReadQuery(db: Database, sql: string, maxRows?: number): {
     columns: string[];
     rows: Record<string, unknown>[];
+    truncated: boolean;
 };
 export declare function insertRow(db: Database, table: string, data: Record<string, unknown>): void;
 export declare function updateRowByKey(db: Database, table: string, pk: {

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

@@ -10,7 +10,13 @@
 import type { Component } from "@gajae-code/tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-import type { SubagentToolDetails } from "./subagent";
+import { type SubagentToolDetails } from "./subagent";
+/** Test-only seam (PR3 deterministic cache-hit assertions). */
+export declare const subagentBodyCacheTestHooks: {
+    readonly bodyRenders: number;
+    readonly size: number;
+    reset(): void;
+};
 export declare const subagentToolRenderer: {
     inline: boolean;
     renderCall(_args: unknown, _options: RenderResultOptions, theme: Theme): Component;

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

@@ -90,4 +90,25 @@ export declare class SubagentTool implements AgentTool<typeof subagentSchema, Su
     constructor(session: ToolSession);
     execute(_toolCallId: string, params: SubagentParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<SubagentToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<SubagentToolDetails>>;
 }
+/**
+ * Canonical, value-based rendered-state signature for the `subagent` await panel.
+ *
+ * Producer-side await gating compares this signature against the last emitted one
+ * and only fires `onUpdate` when the *rendered* state actually changed. Unchanged
+ * idle ticks therefore stop rebuilding the renderer component and stop mutating
+ * transcript lines above the viewport, which is what triggers TUI full-redraw
+ * storms (`tui.ts` `firstChanged < viewportTop`).
+ *
+ * It is deliberately value-based, never object identity: `AsyncJobManager.record-
+ * SubagentProgress` stores a `structuredClone` but `getSubagentProgress` returns
+ * the retained object by reference, so identity comparison would be both noisy and
+ * unsafe.
+ *
+ * Time-derived fields are intentionally excluded so the panel does not churn while
+ * idle: 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.
+ */
+export declare function subagentAwaitRenderedStateSignature(subagents: readonly SubagentSnapshot[]): string;
 export {};

package/dist/types/tools/ultragoal-ask-guard.d.ts

@@ -0,0 +1,5 @@
+import type { AgentTool } from "@gajae-code/agent-core";
+import { type UltragoalAskBlockDiagnostic } from "../gjc-runtime/ultragoal-guard";
+export declare function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiagnostic): string;
+export declare function assertUltragoalAskAllowed(cwd: string): Promise<void>;
+export declare function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: () => string): T;

package/dist/types/web/search/index.d.ts

@@ -10,7 +10,7 @@ import * as z from "zod/v4";
 import type { CustomTool } from "../../extensibility/custom-tools/types";
 import type { ToolSession } from "../../tools";
 import { type SearchRenderDetails } from "./render";
-import type { SearchProviderId } from "./types";
+import type { ActiveSearchModelContext, SearchProviderId } from "./types";
 /** Web search tool parameters schema */
 export declare const webSearchSchema: z.ZodObject<{
     query: z.ZodString;
@@ -40,7 +40,7 @@ export declare function runSearchQuery(params: SearchQueryParams, options?: {
     authStorage?: AuthStorage;
     sessionId?: string;
     signal?: AbortSignal;
-    activeModelProvider?: string;
+    activeModelContext?: ActiveSearchModelContext;
 }): Promise<{
     content: Array<{
         type: "text";
@@ -80,6 +80,6 @@ export declare class WebSearchTool implements AgentTool<typeof webSearchSchema,
 /** Web search tool as CustomTool (for TUI rendering support) */
 export declare const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRenderDetails>;
 export declare function getSearchTools(): CustomTool<any, any>[];
-export { getSearchProvider, setPreferredSearchProvider } from "./provider";
+export { getSearchProvider, setPreferredSearchProvider, setSearchFallbackProviders } from "./provider";
 export type { SearchProviderId as SearchProvider, SearchResponse } from "./types";
-export { isSearchProviderPreference } from "./types";
+export { isConfigurableSearchProviderId, isSearchProviderPreference } from "./types";

package/dist/types/web/search/provider.d.ts

@@ -1,28 +1,24 @@
 import type { AuthStorage } from "@gajae-code/ai";
 import type { SearchProvider } from "./providers/base";
-import type { SearchProviderId } from "./types";
+import type { ActiveSearchModelContext, SearchProviderId } from "./types";
 export type { SearchParams } from "./providers/base";
 export { SearchProvider } from "./providers/base";
-/** Cheap, sync metadata accessor — never triggers a provider load. */
 export declare function getSearchProviderLabel(id: SearchProviderId): string;
-/**
- * Resolve and cache a provider instance. First call for a given id loads the
- * underlying module; subsequent calls return the cached singleton.
- */
 export declare function getSearchProvider(id: SearchProviderId): Promise<SearchProvider>;
 export declare const SEARCH_PROVIDER_ORDER: SearchProviderId[];
-/** Set the preferred web search provider from settings */
 export declare function setPreferredSearchProvider(provider: SearchProviderId | "auto"): void;
-/**
- * Resolve the ordered provider chain for a search request.
- *
- * Resolution is active-model-gated, never credential-scanning:
- *   1. An explicitly preferred provider (settings) that is available is primary.
- *   2. Otherwise the active model's own native search is primary, but only when
- *      that provider's own credentials are present (its `isAvailable()`).
- *   3. DuckDuckGo (keyless) is always appended as the terminal fallback, so a
- *      missing primary — or a primary runtime failure — still returns results
- *      with zero configuration. Keyed standalone providers are never
- *      auto-selected; they are reachable only via explicit selection (step 1).
- */
-export declare function resolveProviderChain(authStorage: AuthStorage, preferredProvider?: SearchProviderId | "auto", activeModelProvider?: string): Promise<SearchProvider[]>;
+export declare function setSearchFallbackProviders(ids: readonly string[]): void;
+export interface ResolveProviderChainOptions {
+    authStorage: AuthStorage;
+    sessionId?: string;
+    signal?: AbortSignal;
+    preferredProvider?: SearchProviderId | "auto";
+    activeModelContext?: ActiveSearchModelContext;
+    fallbackProviders?: readonly SearchProviderId[];
+}
+export declare function looksHostedModelId(modelId: string | undefined): boolean;
+export declare function isLocalBaseUrl(baseUrl: string | undefined): boolean;
+export declare function inferNativeProviderFromModel(ctx: ActiveSearchModelContext | undefined): SearchProviderId | undefined;
+export declare function canUseGenericCredentials(authStorage: AuthStorage, ctx: ActiveSearchModelContext | undefined, sessionId?: string, signal?: AbortSignal): Promise<boolean>;
+export declare function shouldTryGenericOpenAICompat(authStorage: AuthStorage, ctx: ActiveSearchModelContext | undefined, sessionId?: string, signal?: AbortSignal): Promise<boolean>;
+export declare function resolveProviderChain(options: ResolveProviderChainOptions): Promise<SearchProvider[]>;

package/dist/types/web/search/providers/base.d.ts

@@ -1,5 +1,5 @@
 import type { AuthStorage } from "@gajae-code/ai";
-import type { SearchProviderId, SearchResponse } from "../types";
+import type { ActiveSearchModelContext, SearchProviderId, SearchResponse } from "../types";
 /**
  * Shared web search parameters passed to providers.
  *
@@ -49,6 +49,7 @@ export interface SearchParams {
      * caller's agent session when available; otherwise omit.
      */
     sessionId?: string;
+    activeModelContext?: ActiveSearchModelContext;
 }
 /** Base class for web search providers. */
 export declare abstract class SearchProvider {

package/dist/types/web/search/providers/openai-compatible.d.ts

@@ -0,0 +1,9 @@
+import type { SearchResponse } from "../types";
+import type { SearchParams } from "./base";
+import { SearchProvider } from "./base";
+export declare class OpenAICompatibleSearchProvider extends SearchProvider {
+    readonly id: "openai-compatible";
+    readonly label = "OpenAI-compatible";
+    isAvailable(): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}

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

@@ -4,9 +4,21 @@
  * Unified types for web search responses across supported providers.
  */
 /** Supported web search providers */
-export type SearchProviderId = "duckduckgo" | "exa" | "brave" | "jina" | "kimi" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex" | "tavily" | "parallel" | "kagi" | "synthetic" | "searxng";
+export type SearchProviderId = "duckduckgo" | "exa" | "brave" | "jina" | "kimi" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex" | "tavily" | "parallel" | "kagi" | "synthetic" | "searxng" | "openai-compatible";
+export type WebSearchMode = "on" | "off" | "auto";
+export interface ActiveSearchModelContext {
+    provider: string;
+    modelId: string;
+    wireModelId?: string;
+    api: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    webSearch?: WebSearchMode;
+}
+export declare const CONFIGURABLE_SEARCH_PROVIDER_IDS: readonly ["duckduckgo", "exa", "brave", "jina", "kimi", "zai", "anthropic", "perplexity", "gemini", "codex", "tavily", "parallel", "kagi", "synthetic", "searxng"];
 export declare function isSearchProviderId(value: string): value is SearchProviderId;
-export declare function isSearchProviderPreference(value: string): value is SearchProviderId | "auto";
+export declare function isConfigurableSearchProviderId(value: string): value is (typeof CONFIGURABLE_SEARCH_PROVIDER_IDS)[number];
+export declare function isSearchProviderPreference(value: string): value is (typeof CONFIGURABLE_SEARCH_PROVIDER_IDS)[number] | "auto";
 /** Source returned by search (all providers) */
 export interface SearchSource {
     title: string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.5.1",
+	"version": "0.5.3",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -51,12 +51,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.5.1",
-		"@gajae-code/agent-core": "0.5.1",
-		"@gajae-code/ai": "0.5.1",
-		"@gajae-code/natives": "0.5.1",
-		"@gajae-code/tui": "0.5.1",
-		"@gajae-code/utils": "0.5.1",
+		"@gajae-code/stats": "0.5.3",
+		"@gajae-code/agent-core": "0.5.3",
+		"@gajae-code/ai": "0.5.3",
+		"@gajae-code/natives": "0.5.3",
+		"@gajae-code/tui": "0.5.3",
+		"@gajae-code/utils": "0.5.3",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/scripts/build-binary.ts

@@ -5,6 +5,12 @@ import * as path from "node:path";
 const packageDir = path.join(import.meta.dir, "..");
 const outputPath = path.join(packageDir, "dist", "gjc");
 const nativeDir = path.join(packageDir, "..", "natives", "native");
+// Lazy native tokenizer entrypoint. `agent-core/compaction` loads this from
+// the explicit native entrypoint instead of a package-name dynamic require of
+// `@gajae-code/natives`, because those fail inside Bun standalone `$bunfs`.
+// Listing the module here makes the absolute target path exist in the compiled
+// bunfs.
+const nativeTokenizerEntrypoint = "../natives/native/index.js";
 
 function shouldAdhocSignDarwinBinary(): boolean {
 	return process.platform === "darwin";
@@ -66,6 +72,7 @@ async function main(): Promise<void> {
 					"../stats/src/sync-worker.ts",
 					"./src/tools/browser/tab-worker-entry.ts",
 					"./src/eval/js/worker-entry.ts",
+					nativeTokenizerEntrypoint,
 					"--outfile",
 					"dist/gjc",
 				],