@gajae-code/coding-agent 0.2.5 → 0.3.1

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

@@ -0,0 +1,85 @@
+import type { SingleResult, TaskToolDetails } from "./types";
+export interface TaskRoi {
+    tokens: number;
+    contextTokens?: number;
+    clonedTokens?: number;
+    costTotal?: number;
+    outputBytes?: number;
+    outputLines?: number;
+    producedChanges: boolean;
+    materialContribution: boolean;
+    lowRoi: boolean;
+}
+export interface TaskResultReceipt {
+    index: number;
+    id: string;
+    agent: string;
+    agentSource: SingleResult["agentSource"];
+    task: string;
+    assignment?: string;
+    description?: string;
+    status: "completed" | "failed" | "aborted" | "merge_failed" | "paused";
+    exitCode: number;
+    aborted?: boolean;
+    paused?: boolean;
+    truncated: boolean;
+    durationMs: number;
+    tokens: number;
+    contextTokens?: number;
+    contextWindow?: number;
+    modelOverride?: string | string[];
+    usage?: SingleResult["usage"];
+    cost?: number;
+    branchName?: string;
+    retryFailure?: {
+        attempt: number;
+        errorSummary: string;
+    };
+    errorSummary?: string;
+    abortSummary?: string;
+    preview: string;
+    previewTruncated: boolean;
+    outputRef?: {
+        uri: string;
+        sizeBytes: number;
+        lineCount: number;
+        sha256?: string;
+    };
+    outputUnavailable?: boolean;
+    review?: {
+        overallCorrectness?: string;
+        findingCount: number;
+        findings?: Array<{
+            severity?: string;
+            summary: string;
+        }>;
+    };
+    extractedToolCounts?: Record<string, number>;
+    forkContext?: SingleResult["forkContext"];
+    roi?: TaskRoi;
+}
+/**
+ * Heuristic task ROI signal built only from receipt-safe accounting fields.
+ * Advisory only: these flags never change task success/failure semantics.
+ */
+export declare function buildTaskRoi(raw: SingleResult): TaskRoi;
+export declare function buildTaskRoiSummary(receipts: readonly TaskResultReceipt[]): TaskToolDetails["roiSummary"];
+export declare function buildTaskReceipt(raw: SingleResult): TaskResultReceipt;
+/**
+ * Raw, pre-sanitization task details: the internal shape produced during task
+ * execution, where `results` are full `SingleResult` objects. The public
+ * `TaskToolDetails` exposes only receipts.
+ */
+export interface RawTaskToolDetails {
+    projectAgentsDir: string | null;
+    results: SingleResult[];
+    totalDurationMs: number;
+    usage?: TaskToolDetails["usage"];
+    async?: TaskToolDetails["async"];
+    forkContextClonedTokens?: number;
+    roiSummary?: TaskToolDetails["roiSummary"];
+}
+/** Central converter from raw task details to receipt-only public details. */
+export declare function sanitizeTaskToolDetails(raw: RawTaskToolDetails): TaskToolDetails;
+export declare function findRawTaskLeakKeys(value: unknown): string[];
+export declare function assertNoRawTaskFields(value: unknown, surface: string): void;

package/dist/types/task/spawn-gate.d.ts

@@ -0,0 +1,38 @@
+/** The hard, locked batch threshold enforced by the runtime gate. */
+export declare const DEFAULT_SPAWN_THRESHOLD = 4;
+/** The justification a large batch or reviewer-spawned explorer must supply to pass the hard gate. */
+export interface SpawnPlanReceipt {
+    whyParallel: string;
+    whyNotLocal: string;
+    independence: string;
+    expectedReceiptShape: string;
+    maxInlineTokens: number;
+}
+export interface SpawnGateRequest {
+    /** Number of children the batch wants to spawn. */
+    childCount: number;
+    /** The spawn-plan receipt, when provided. */
+    plan?: SpawnPlanReceipt;
+}
+export interface ReviewerExploreGateRequest {
+    /** Agent type/name doing the spawning, when known. */
+    spawningAgentType?: string | null;
+    /** Target agent type/name requested by the task call. */
+    targetAgent: string;
+    /** The spawn-plan receipt, when provided. */
+    plan?: SpawnPlanReceipt;
+}
+export type SpawnGateOutcome = "allowed" | "rejected";
+export interface SpawnGateDecision {
+    outcome: SpawnGateOutcome;
+    /** Human-readable reason, suitable for a blocked-result message. */
+    reason: string;
+    /** Whether a plan was required for this request. */
+    planRequired: boolean;
+    /** Missing plan field names when rejected for an incomplete plan. */
+    missingFields: readonly string[];
+}
+export declare function findMissingPlanFields(plan: SpawnPlanReceipt | undefined): string[];
+export declare function decide(childCount: number, threshold: number, plan: SpawnPlanReceipt | undefined): SpawnGateDecision;
+export declare function evaluateSpawnGate(request: SpawnGateRequest): SpawnGateDecision;
+export declare function evaluateReviewerExploreGate(request: ReviewerExploreGateRequest): SpawnGateDecision;

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

@@ -1,11 +1,14 @@
 import type { ThinkingLevel } from "@gajae-code/agent-core";
 import type { Usage } from "@gajae-code/ai";
 import * as z from "zod/v4";
+import type { TaskResultReceipt } from "./receipt";
 import { type TaskSimpleMode } from "./simple-mode";
+import type { SpawnPlanReceipt } from "./spawn-gate";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
 export type ForkContextPolicy = "forbidden" | "allowed";
+export type ForkContextMode = "none" | "receipt" | "last-turn" | "bounded" | "full";
 /** Maximum output bytes per agent */
 export declare const MAX_OUTPUT_BYTES: number;
 /** Maximum output lines per agent */
@@ -32,7 +35,7 @@ export interface SubagentLifecyclePayload {
     agent: string;
     agentSource: AgentSource;
     description?: string;
-    status: "started" | "completed" | "failed" | "aborted";
+    status: "started" | "completed" | "failed" | "aborted" | "paused";
     sessionFile?: string;
     index: number;
 }
@@ -41,7 +44,13 @@ export declare const taskItemSchema: z.ZodObject<{
     id: z.ZodString;
     description: z.ZodString;
     assignment: z.ZodString;
-    inheritContext: z.ZodOptional<z.ZodBoolean>;
+    inheritContext: z.ZodOptional<z.ZodEnum<{
+        bounded: "bounded";
+        full: "full";
+        "last-turn": "last-turn";
+        none: "none";
+        receipt: "receipt";
+    }>>;
 }, z.core.$strip>;
 export type TaskItem = z.infer<typeof taskItemSchema>;
 export declare const taskSchema: z.ZodObject<{
@@ -50,7 +59,20 @@ export declare const taskSchema: z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const taskSchemaNoIsolation: z.ZodObject<{
@@ -59,7 +81,20 @@ export declare const taskSchemaNoIsolation: z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
@@ -68,7 +103,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -76,7 +124,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -84,7 +145,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -92,7 +166,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -100,7 +187,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -108,7 +208,20 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
-        inheritContext: z.ZodOptional<z.ZodBoolean>;
+        inheritContext: z.ZodOptional<z.ZodEnum<{
+            bounded: "bounded";
+            full: "full";
+            "last-turn": "last-turn";
+            none: "none";
+            receipt: "receipt";
+        }>>;
+    }, z.core.$strip>>;
+    spawnPlan: z.ZodOptional<z.ZodObject<{
+        whyParallel: z.ZodString;
+        whyNotLocal: z.ZodString;
+        independence: z.ZodString;
+        expectedReceiptShape: z.ZodString;
+        maxInlineTokens: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>];
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
@@ -123,6 +236,7 @@ export interface TaskParams {
     agent: string;
     context?: string;
     schema?: string;
+    spawnPlan?: SpawnPlanReceipt;
     tasks: TaskItem[];
     isolated?: boolean;
 }
@@ -171,7 +285,7 @@ export interface AgentProgress {
     id: string;
     agent: string;
     agentSource: AgentSource;
-    status: "pending" | "running" | "completed" | "failed" | "aborted";
+    status: "pending" | "running" | "completed" | "failed" | "aborted" | "paused";
     task: string;
     assignment?: string;
     description?: string;
@@ -213,6 +327,7 @@ export interface AgentProgress {
     retryState?: {
         attempt: number;
         maxAttempts: number;
+        unbounded?: boolean;
         delayMs: number;
         errorMessage: string;
         startedAtMs: number;
@@ -261,6 +376,7 @@ export interface SingleResult {
     error?: string;
     aborted?: boolean;
     abortReason?: string;
+    paused?: boolean;
     /** Aggregated usage from the subprocess, accumulated incrementally from message_end events. */
     usage?: Usage;
     /** Output path for the task result */
@@ -271,6 +387,8 @@ export interface SingleResult {
     branchName?: string;
     /** Nested repo patches to apply after parent merge */
     nestedPatches?: NestedRepoPatch[];
+    /** Whether isolated execution produced a non-empty root or nested patch. */
+    producedChanges?: boolean;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;
     /**
@@ -287,21 +405,87 @@ export interface SingleResult {
     outputMeta?: {
         lineCount: number;
         charCount: number;
+        byteSize?: number;
+        sha256?: string;
+    };
+    /** Fork-context seed accounting for this subagent, when inherited parent context was cloned. */
+    forkContext?: {
+        mode: ForkContextMode;
+        clonedTokens: number;
     };
 }
 /** Tool details for TUI rendering */
 export interface TaskToolDetails {
     projectAgentsDir: string | null;
-    results: SingleResult[];
+    results: TaskResultReceipt[];
     totalDurationMs: number;
     /** Aggregated usage across all subagents. */
     usage?: Usage;
-    outputPaths?: string[];
+    /** Aggregate cloned tokens copied into fork-context seeds across subagents. */
+    forkContextClonedTokens?: number;
+    roiSummary?: {
+        childCount: number;
+        totalTokens: number;
+        totalCostTotal?: number;
+        totalClonedTokens?: number;
+        /** Advisory ids for terminal children that spent tokens without detectable output/review/changes. */
+        lowRoiChildIds: string[];
+    };
     progress?: AgentProgress[];
     async?: {
-        state: "running" | "completed" | "failed";
+        state: "running" | "paused" | "queued" | "completed" | "failed";
         jobId: string;
         type: "task";
     };
 }
+/**
+ * Persisted per-turn / per-subagent token record (Phase 0 instrumentation).
+ *
+ * Additive: this does not alter any existing task result shape. It is the
+ * durable, model-independent unit the deterministic orchestration-token
+ * benchmark (`@gajae-code/orchestration-token-benchmark`) consumes to measure
+ * token efficiency without any live-model calls.
+ */
+export interface TaskTokenLog {
+    /** Subagent id, or "root" for the orchestrator's own turn. */
+    subagentId: string;
+    /** Agent name for attribution, when known. */
+    agent?: string;
+    /** 1-based turn index within the subagent's session. */
+    turn: number;
+    /** ISO-8601 timestamp the turn completed. */
+    at: string;
+    /** Cost-bearing input tokens (excludes cache reads), mirrors `Usage.input`. */
+    input: number;
+    /** Total output tokens for the turn, mirrors `Usage.output`. */
+    output: number;
+    /** Tokens read from the prompt cache, mirrors `Usage.cacheRead`. */
+    cacheRead: number;
+    /** Tokens written to the prompt cache, mirrors `Usage.cacheWrite`. */
+    cacheWrite: number;
+    /** input + output + cacheRead + cacheWrite. */
+    totalTokens: number;
+    /** Latest per-turn context-window occupancy, when known. */
+    contextTokens?: number;
+    /** Estimated USD cost for the turn, when known. */
+    cost?: number;
+    /** Model id used for the turn, when known. */
+    model?: string;
+}
+/**
+ * Deterministic aggregate token metrics computed from a set of `TaskTokenLog`
+ * entries. The cache-hit-rate field is the primary prompt-cache signal called
+ * out by the prefix-stability invariant (see the approved plan).
+ */
+export interface TaskTokenMetrics {
+    /** Number of token-log entries aggregated. */
+    turns: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    totalTokens: number;
+    /** cacheRead / (input + cacheRead); 0 when there is no input-class traffic. */
+    cacheHitRate: number;
+}
 export {};

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

@@ -52,6 +52,12 @@ export interface CronDeleteToolDetails {
 export declare function clearOwnerSchedules(ownerId: string | undefined): void;
 /** Reset every owner's schedule store. Test-only. */
 export declare function resetCronRegistryForTests(): void;
+/** Subscribe to cron schedule-set changes. Returns an unsubscribe function. */
+export declare function onCronChange(cb: () => void): () => void;
+/** Snapshot the scheduled cron jobs for an owner (or all owners when omitted). */
+export declare function listCronSnapshots(ownerId?: string): CronJobSnapshot[];
+/** Delete a scheduled cron job by owner-scoped id. Returns true when removed. */
+export declare function deleteCronJobById(ownerId: string | undefined, id: string): boolean;
 export declare function validateCronExpression(expression: string): void;
 export declare function findNextCronMatchMs(expression: string, afterMs: number, deadlineMs?: number): number | undefined;
 export declare function calculateCronFireTimeMs(params: {

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

@@ -102,6 +102,8 @@ export interface ToolSession {
     requireYieldTool?: boolean;
     /** Task recursion depth (0 = top-level, 1 = first child, etc.) */
     taskDepth?: number;
+    /** Current role-agent type/name for nested task sessions. */
+    currentAgentType?: string;
     /** Get session file */
     getSessionFile: () => string | null;
     /** Get eval kernel owner ID for session-scoped retained-kernel cleanup. */

package/dist/types/tools/path-utils.d.ts

@@ -116,6 +116,7 @@ export declare function resolveReadPath(filePath: string, cwd: string): string;
 export interface ToolScopeOptions {
     rawPaths: string[];
     cwd: string;
+    getArtifactsDir?: () => string | null;
     /** Verb used in the "Cannot {action} internal URL without a backing file: …" message. */
     internalUrlAction: string;
     /** Collect absolute paths flagged immutable by their internal-URL handler. */

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

@@ -8,13 +8,24 @@ declare const subagentSchema: z.ZodObject<{
         cancel: "cancel";
         inspect: "inspect";
         list: "list";
+        pause: "pause";
+        resume: "resume";
+        steer: "steer";
     }>;
     ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    pause: z.ZodOptional<z.ZodBoolean>;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
     limit: z.ZodOptional<z.ZodNumber>;
+    verbosity: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+        preview: "preview";
+        receipt: "receipt";
+    }>>;
 }, z.core.$strip>;
 type SubagentParams = z.infer<typeof subagentSchema>;
-type SubagentStatus = "running" | "completed" | "failed" | "cancelled" | "not_found" | "already_completed";
+type SubagentStatus = "running" | "paused" | "queued" | "completed" | "failed" | "cancelled" | "not_found" | "already_completed";
 export interface SubagentSnapshot {
     id: string;
     jobId: string;
@@ -27,6 +38,9 @@ export interface SubagentSnapshot {
     durationMs: number;
     resultText?: string;
     errorText?: string;
+    resultPreview?: string;
+    outputRef?: string;
+    truncated?: boolean;
     guidance?: string;
 }
 export interface SubagentToolDetails {
@@ -45,10 +59,21 @@ export declare class SubagentTool implements AgentTool<typeof subagentSchema, Su
             cancel: "cancel";
             inspect: "inspect";
             list: "list";
+            pause: "pause";
+            resume: "resume";
+            steer: "steer";
         }>;
         ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        id: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+        pause: z.ZodOptional<z.ZodBoolean>;
         timeout_ms: z.ZodOptional<z.ZodNumber>;
         limit: z.ZodOptional<z.ZodNumber>;
+        verbosity: z.ZodOptional<z.ZodEnum<{
+            full: "full";
+            preview: "preview";
+            receipt: "receipt";
+        }>>;
     }, z.core.$strip>;
     readonly strict = true;
     readonly loadMode = "discoverable";

package/package.json

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

package/scripts/build-binary.ts

@@ -4,6 +4,7 @@ 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");
 
 function shouldAdhocSignDarwinBinary(): boolean {
 	return process.platform === "darwin";
@@ -21,6 +22,11 @@ async function runCommand(command: string[], env: NodeJS.ProcessEnv = Bun.env):
 		throw new Error(`Command failed with exit code ${exitCode}: ${command.join(" ")}`);
 	}
 }
+async function stageWorkspaceNativeAddons(): Promise<void> {
+	await Array.fromAsync(new Bun.Glob("pi_natives.*.node").scan({ cwd: nativeDir }), async filename => {
+		await Bun.write(path.join(packageDir, "dist", filename), Bun.file(path.join(nativeDir, filename)));
+	});
+}
 
 async function main(): Promise<void> {
 	await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--generate"]);
@@ -62,6 +68,7 @@ async function main(): Promise<void> {
 				buildEnv,
 			);
 
+			await stageWorkspaceNativeAddons();
 			// Bun 1.3.12 emits a truncated Mach-O signature on darwin builds.
 			if (shouldAdhocSignDarwinBinary()) {
 				await runCommand(["codesign", "--force", "--sign", "-", outputPath]);