@agent-native/core 0.204.0 → 0.204.1-nightly-20261008034100

package/dist/agent/run-store.js

@@ -6,7 +6,7 @@ import { widenIntColumnsToBigInt } from "../db/widen-columns.js";
 import { lockAndAssertServicePrincipalMayStartRun, prepareServicePrincipalRunStart, recordServicePrincipalDenial, } from "../org/service-principal-guard.js";
 import { captureError } from "../server/capture-error.js";
 import { isRequestedStopAbortReason } from "./abort-reasons.js";
-import { admitAutoContinue, } from "./auto-continue.js";
+import { admitAutoContinue, admitManualContinue, } from "./auto-continue.js";
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "./engine/credential-errors.js";
 import { isContinuationTerminalReason } from "./types.js";
 let _initPromise;
@@ -697,6 +697,31 @@ export async function countRunsForTurn(threadId, turnId) {
     const count = Number(raw);
     return Number.isFinite(count) ? count : 0;
 }
+/**
+ * The newest run of the turn before `turnId` in a thread: how the previous
+ * request ended. Null when the thread has no earlier turn.
+ */
+export async function getPreviousTurnNewestRun(threadId, turnId) {
+    await ensureRunTables();
+    const { rows } = await getDbExec().execute({
+        sql: `SELECT COALESCE(turn_id, id) AS turn_id, status, terminal_reason
+          FROM agent_runs
+          WHERE thread_id = ?
+            AND COALESCE(turn_id, id) <> ?
+            AND dispatch_mode IS DISTINCT FROM 'turn-abort'
+          ORDER BY started_at DESC
+          LIMIT 1`,
+        args: [threadId, turnId],
+    });
+    const row = rows[0];
+    return row
+        ? {
+            turnId: row.turn_id,
+            status: row.status,
+            terminalReason: row.terminal_reason,
+        }
+        : null;
+}
 export async function getTurnInitiatorByRun(runId) {
     await ensureRunTables();
     const { rows } = await getDbExec().execute({
@@ -810,7 +835,12 @@ export async function tryClaimRunSlot(threadId, runId, maxStaleMs, options) {
     const client = getDbExec();
     const now = Date.now();
     const turnId = options?.turnId ?? runId;
-    const replayCompletedTurn = options?.replayCompletedTurn === true && Boolean(options.turnId);
+    const continueOf = options?.continueOf;
+    // A continuation names a run that already ended, so replaying the turn's
+    // last finished run would hand back the stop it asked to move past.
+    const replayCompletedTurn = options?.replayCompletedTurn === true &&
+        Boolean(options.turnId) &&
+        !continueOf;
     if (!client.transaction) {
         throw new Error("Atomic run-slot claims require transaction support");
     }
@@ -885,40 +915,54 @@ export async function tryClaimRunSlot(threadId, runId, maxStaleMs, options) {
         }
         // Admitted under the thread's slot lock, so two tabs continuing the same
         // stop start one run and the count of continuations stays exact.
-        if (options?.autoContinueOf) {
+        if (continueOf) {
             const turnRuns = await tx.execute({
                 sql: `SELECT id, status, terminal_reason, completed_at,
                      COUNT(auto_continue_of) OVER () AS auto_continues,
-                     MIN(started_at) OVER () AS turn_started_at
+                     MIN(started_at) OVER () AS turn_started_at,
+                     EXISTS (
+                       SELECT 1 FROM agent_runs later
+                       WHERE later.thread_id = ?
+                         AND COALESCE(later.turn_id, later.id) <> ?
+                         AND later.started_at > agent_runs.started_at
+                     ) AS later_turn_started
               FROM agent_runs
               WHERE thread_id = ? AND turn_id = ?
                 AND dispatch_mode IS DISTINCT FROM 'turn-abort'
               ORDER BY started_at DESC LIMIT 1`,
-                args: [threadId, turnId],
+                args: [threadId, turnId, threadId, turnId],
             });
             const row = turnRuns.rows[0];
-            const admission = admitAutoContinue({
-                turn: row
-                    ? {
-                        newest: {
-                            id: row.id,
-                            status: row.status,
-                            terminalReason: row.terminal_reason,
-                            completedAt: row.completed_at === null ? null : Number(row.completed_at),
-                        },
-                        autoContinues: Number(row.auto_continues),
-                        startedAt: Number(row.turn_started_at),
-                    }
-                    : null,
-                stoppedRunId: options.autoContinueOf,
-                nowMs: now,
-            });
+            const turn = row
+                ? {
+                    newest: {
+                        id: row.id,
+                        status: row.status,
+                        terminalReason: row.terminal_reason,
+                        completedAt: row.completed_at === null ? null : Number(row.completed_at),
+                    },
+                    autoContinues: Number(row.auto_continues),
+                    startedAt: Number(row.turn_started_at),
+                }
+                : null;
+            const admission = continueOf.trigger === "auto"
+                ? admitAutoContinue({
+                    turn,
+                    stoppedRunId: continueOf.runId,
+                    nowMs: now,
+                })
+                : admitManualContinue({
+                    turn,
+                    stoppedRunId: continueOf.runId,
+                    laterTurnStarted: row?.later_turn_started === true ||
+                        row?.later_turn_started === "t",
+                });
             if (!admission.admit) {
                 return {
                     result: {
                         claimed: false,
                         activeRunId: null,
-                        autoContinueRefused: admission.code,
+                        continueRefused: admission.code,
                     },
                 };
             }
@@ -937,7 +981,8 @@ export async function tryClaimRunSlot(threadId, runId, maxStaleMs, options) {
                 options?.dispatchMode ?? null,
                 options?.dispatchPayload ?? null,
                 continuationOrder,
-                options?.autoContinueOf ?? null,
+                // Only automatic continuations count toward the turn's cap.
+                continueOf?.trigger === "auto" ? continueOf.runId : null,
             ],
         });
         if ((inserted.rowsAffected ?? 0) !== 1) {
@@ -1416,7 +1461,7 @@ function priorDiagStageLabel(raw) {
     }
     return raw.slice(0, 120);
 }
-async function reapSingleStaleRun(runId, maxStaleMs) {
+async function reapSingleStaleRun(runId, source, maxStaleMs) {
     const completedAt = Date.now();
     const staleClause = typeof maxStaleMs === "number"
         ? `${livenessBasisSql()} < ?`
@@ -1511,6 +1556,11 @@ async function reapSingleStaleRun(runId, maxStaleMs) {
         forensics = read.forensics;
         priorStageInfo = read.priorStageInfo;
     }
+    // Saved before the successor starts: a successor that folds its own reply
+    // first would have this older run's steps land after its, and take its
+    // error and status.
+    if (reaped)
+        await finalizeStaleRun(runId, source);
     if (reaped && outcome && outcome.outcome !== "not_background") {
         const outcomeDetail = outcome.outcome === "recovered"
             ? `recovered successorRunId=${outcome.successorRunId}`
@@ -1532,12 +1582,9 @@ export async function reapIfStale(runId, maxStaleMs) {
     await ensureRunTables();
     if (await reconcileTerminalRunFromEvents(runId))
         return false;
-    const reaped = await reapSingleStaleRun(runId, maxStaleMs);
+    const reaped = await reapSingleStaleRun(runId, "reap-if-stale", maxStaleMs);
     if (!reaped && (await reconcileTerminalRunFromEvents(runId)))
         return false;
-    if (reaped) {
-        await safeAppendTerminalRunEvent(runId, STALE_RUN_ERROR_EVENT, "reap-if-stale");
-    }
     return reaped;
 }
 export async function reapUnclaimedBackgroundRun(runId) {
@@ -1826,6 +1873,51 @@ export async function getRunById(runId) {
         terminalReason: r.terminal_reason ?? null,
     };
 }
+/**
+ * What saving a run the server ended on its behalf needs: the run's ledger,
+ * and whether anything ran after it in its turn or in a later turn.
+ */
+export async function readStoppedRunForThreadFold(runId) {
+    await ensureRunTables();
+    const client = getDbExec();
+    const { rows } = await client.execute({
+        sql: `SELECT r.thread_id, COALESCE(r.turn_id, r.id) AS turn_id,
+                 r.status, r.started_at,
+                 EXISTS (
+                   SELECT 1 FROM agent_runs later
+                   WHERE later.thread_id = r.thread_id
+                     AND COALESCE(later.turn_id, later.id) = COALESCE(r.turn_id, r.id)
+                     AND later.id <> r.id
+                     AND later.started_at >= r.started_at
+                     AND later.dispatch_mode IS DISTINCT FROM 'turn-abort'
+                 ) AS continued_in_turn,
+                 EXISTS (
+                   SELECT 1 FROM agent_runs later
+                   WHERE later.thread_id = r.thread_id
+                     AND COALESCE(later.turn_id, later.id) <> COALESCE(r.turn_id, r.id)
+                     AND later.started_at > r.started_at
+                 ) AS later_turn_started
+          FROM agent_runs r WHERE r.id = ?`,
+        args: [runId],
+    });
+    const row = rows[0];
+    // A sweep can name a run whose worker answered again before it was reaped;
+    // that worker still saves its own reply.
+    if (!row || row.status === "running")
+        return null;
+    const events = [];
+    for (const { seq, eventData } of await getRunEventsSince(runId, 0)) {
+        events.push({ seq, event: JSON.parse(eventData) });
+    }
+    return {
+        threadId: row.thread_id,
+        turnId: row.turn_id,
+        startedAt: Number(row.started_at),
+        events,
+        continuedInTurn: row.continued_in_turn === true || row.continued_in_turn === "t",
+        laterTurnStarted: row.later_turn_started === true || row.later_turn_started === "t",
+    };
+}
 export async function getLastTerminalRunEvent(runId) {
     await ensureRunTables();
     const client = getDbExec();
@@ -2057,7 +2149,7 @@ export async function reapAllStaleRuns() {
         if (typeof id !== "string")
             continue;
         try {
-            if (await reapSingleStaleRun(id))
+            if (await reapSingleStaleRun(id, "reap-all-stale"))
                 reapedCount += 1;
         }
         catch (error) {
@@ -2256,7 +2348,7 @@ async function cleanupOldRunsInternal(olderThanMs, erroredOlderThanMs) {
     for (const row of stale.rows) {
         const id = row.id;
         if (typeof id === "string") {
-            await safeAppendTerminalRunEvent(id, STALE_RUN_ERROR_EVENT, "cleanup-old-runs");
+            await finalizeStaleRun(id, "cleanup-old-runs");
         }
     }
     await pruneAndRollUpPrunedRunOutcomes(client, cutoff, erroredCutoff);
@@ -2308,6 +2400,28 @@ export async function listErroredRuns(options) {
 export async function ensureTerminalRunEvent(runId, event) {
     return appendTerminalRunEvent(runId, event);
 }
+/**
+ * Ends a run the server reaped because its worker stopped: records the stop
+ * in the run's ledger, then saves what the run did into its thread, which the
+ * dead worker never got to do.
+ */
+async function finalizeStaleRun(runId, source) {
+    await safeAppendTerminalRunEvent(runId, STALE_RUN_ERROR_EVENT, source);
+    try {
+        const { foldReapedRunIntoThread } = await import("./reaped-run-thread.js");
+        await foldReapedRunIntoThread(runId);
+    }
+    catch (error) {
+        captureError(error, {
+            tags: {
+                component: "agent-run-store",
+                operation: "fold-reaped-run",
+                source,
+            },
+            extra: { runId },
+        });
+    }
+}
 async function safeAppendTerminalRunEvent(runId, event, source) {
     let firstError;
     try {

package/dist/agent/thread-data-builder.d.ts

@@ -75,6 +75,12 @@ export declare function resumeThreadHistoryForRequest(threadData: string | Recor
     messages: EngineMessage[];
     foundTurnPrompt: boolean;
 };
+/**
+ * The turn the thread's newest prompt was sent in, when the server stamped
+ * it. A prompt whose run was refused before it started has no run row, so
+ * this is how a continuation learns a newer prompt is waiting.
+ */
+export declare function latestPromptTurnId(threadData: string | Record<string, unknown>): string | undefined;
 export declare function threadMessageTextForEngine(message: any): string;
 export interface CodeAgentThreadTranscriptEvent {
     id: string;
@@ -119,6 +125,16 @@ export declare function applySubmittedUserMessage(repo: any, userMessage: UserMe
 } | {
     status: "already_claimed" | "claim_expired";
 };
+/**
+ * Whether a stored user message is the prompt this run answers, rather than
+ * one sent after it started. Messages saved without the server's turn stamp
+ * fall back to their creation time.
+ */
+export declare function isRunPrompt(user: any, run: {
+    runId: string;
+    turnId?: string | null;
+    startedAt: number;
+}): boolean;
 export type ThreadSuggestionRun = Pick<ActiveRun, "runId" | "threadId" | "turnId" | "startedAt" | "status" | "events" | "abortReason">;
 export declare function foldThreadRunSuggestions(repo: any, run: ThreadSuggestionRun): any;
 export declare function mergeThreadDataForClientSave(existingRepo: any, incomingRepo: any, options?: MergeThreadDataOptions): any;

package/dist/agent/thread-data-builder.js

@@ -864,6 +864,16 @@ export function resumeThreadHistoryForRequest(threadData) {
         foundTurnPrompt: true,
     };
 }
+/**
+ * The turn the thread's newest prompt was sent in, when the server stamped
+ * it. A prompt whose run was refused before it started has no run row, so
+ * this is how a continuation learns a newer prompt is waiting.
+ */
+export function latestPromptTurnId(threadData) {
+    const data = typeof threadData === "string" ? JSON.parse(threadData) : threadData;
+    const turnId = latestStoredUser(data)?.metadata?.custom?.submittedTurnId;
+    return typeof turnId === "string" ? turnId : undefined;
+}
 const MAX_INTEGRATION_ARTIFACTS_IN_CONTEXT = 12;
 const MAX_INTEGRATION_ARTIFACT_FIELD_CHARS = 500;
 function boundedString(value) {
@@ -1389,21 +1399,28 @@ function latestStoredUser(repo) {
         ?.map((entry) => getStoredMessage(entry))
         .findLast((message) => message?.role === "user");
 }
+/**
+ * Whether a stored user message is the prompt this run answers, rather than
+ * one sent after it started. Messages saved without the server's turn stamp
+ * fall back to their creation time.
+ */
+export function isRunPrompt(user, run) {
+    const userContext = user?.metadata?.custom;
+    if (userContext?.submittedTurnId) {
+        return userContext.submittedTurnId === run.turnId;
+    }
+    return (userContext?.submittedRunId === run.runId ||
+        !user?.createdAt ||
+        new Date(user.createdAt).getTime() <= run.startedAt);
+}
 function clearThreadSuggestions(repo) {
     return repo.agentKit
         ? { ...repo, agentKit: { ...repo.agentKit, suggestions: [] } }
         : repo;
 }
 export function foldThreadRunSuggestions(repo, run) {
-    const user = latestStoredUser(repo);
-    const userContext = user?.metadata?.custom;
-    if (userContext?.submittedTurnId
-        ? userContext.submittedTurnId !== run.turnId
-        : userContext?.submittedRunId !== run.runId &&
-            user?.createdAt &&
-            new Date(user.createdAt).getTime() > run.startedAt) {
+    if (!isRunPrompt(latestStoredUser(repo), run))
         return repo;
-    }
     const previous = repo.agentKit ?? {};
     const latest = latestSnapshotRun(previous.runs);
     const startedAt = new Date(run.startedAt).toISOString();
@@ -2872,6 +2889,11 @@ export function foldAssistantTurn(repo, assistantMsg, options) {
     }
     if (incomingCustom.continued !== true)
         delete mergedCustom.continued;
+    // A turn's failure is its newest run's: a run that continued past an
+    // earlier stop clears the stop's error instead of inheriting it.
+    if (!runAlreadyFolded && incomingCustom.runError === undefined) {
+        delete mergedCustom.runError;
+    }
     const mergedMessage = {
         ...lastMsg,
         content: normalizeAssistantToolCallIds({

package/dist/agent/thread-message-projection.js

@@ -157,13 +157,15 @@ function representedToolCallMessageIds(value, toolCalls) {
                 ? rootCall.id
                 : undefined;
         const call = id ? byId.get(id) : undefined;
+        // A tool call's identity is its id, name, and args. Never compare results:
+        // the stored root keeps the model-facing text while the snapshot output is
+        // the structured chat-UI result, so one call never compares equal and its
+        // reply renders twice.
         if (!call ||
             (typeof rootCall.toolName === "string" &&
                 rootCall.toolName !== call.name) ||
             (Object.prototype.hasOwnProperty.call(rootCall, "args") &&
-                !sameValue(rootCall.args, call.input)) ||
-            (Object.prototype.hasOwnProperty.call(rootCall, "result") &&
-                !sameValue(rootCall.result, call.output))) {
+                !sameValue(rootCall.args, call.input))) {
             return undefined;
         }
         if (typeof call.messageId === "string")

package/dist/agent/tool-search.js

@@ -500,7 +500,11 @@ function scoreTool(input) {
         .join(" "));
     const all = `${name} ${source} ${description} ${params} ${input.kind}`;
     const phrase = searchableText(input.query);
-    let score = 0;
+    // A query that is a tool's whole name is a request for that tool, not for
+    // whatever else repeats its words.
+    let score = input.name.toLowerCase() === input.query.trim().toLowerCase()
+        ? EXACT_NAME_SCORE
+        : 0;
     if (name.includes(phrase))
         score += 14;
     if (source && source.includes(phrase))

package/dist/agent/types.d.ts

@@ -170,6 +170,8 @@ export interface AgentChatRequest {
     internalContinuation?: boolean;
     /** The time-limit stop this request continues, in the same turn. */
     autoContinueOfRunId?: string;
+    /** The stopped run a person chose to continue, in the same turn. */
+    continueOfRunId?: string;
     __backgroundRun?: {
         runId: string;
         turnId?: string;
@@ -273,6 +275,7 @@ export type AgentChatEvent = {
     input?: AgentToolInput;
     result: string;
     isError?: boolean;
+    errorCode?: string;
     completedSideEffect?: boolean;
     replayed?: true;
     fileMutation?: AgentFileMutationProof;

package/dist/audit/config.d.ts

@@ -2,6 +2,12 @@ import type { ActionAuditConfig, AuditActorKind, AuditStatus } from "./types.js"
 export declare function normalizeAuditConfig(raw: unknown): ActionAuditConfig | undefined;
 export declare function resolveAuditAttach(config: ActionAuditConfig | undefined, readOnly: boolean | undefined): boolean;
 export declare function shouldRecordAudit(config: ActionAuditConfig | undefined, actionName: string): boolean;
+/**
+ * Agent protocols: the app's own agent (`tool`) and the MCP, WebMCP, and A2A
+ * surfaces outside agents use. A call over one records as the agent acting
+ * for the signed-in user; that user's email does not make it a click.
+ */
+export declare const AGENT_AUDIT_CALLERS: ReadonlySet<string>;
 export declare function deriveActorKind(caller: string | undefined, actorEmail: string | undefined | null, orgId?: string | null): AuditActorKind;
 export declare function isAuditDisabled(): boolean;
 export type { AuditStatus };

package/dist/audit/config.js

@@ -29,11 +29,22 @@ export function shouldRecordAudit(config, actionName) {
         return false;
     return true;
 }
+/**
+ * Agent protocols: the app's own agent (`tool`) and the MCP, WebMCP, and A2A
+ * surfaces outside agents use. A call over one records as the agent acting
+ * for the signed-in user; that user's email does not make it a click.
+ */
+export const AGENT_AUDIT_CALLERS = new Set([
+    "tool",
+    "mcp",
+    "webmcp",
+    "a2a",
+]);
 export function deriveActorKind(caller, actorEmail, orgId) {
     const serviceIdentity = parseServiceIdentityEmail(actorEmail);
     if (serviceIdentity && serviceIdentity.orgId === orgId)
         return "service";
-    if (caller === "tool")
+    if (caller && AGENT_AUDIT_CALLERS.has(caller))
         return "agent";
     return actorEmail ? "human" : "system";
 }

package/dist/audit/index.d.ts

@@ -1,5 +1,5 @@
 export type { ActionAuditConfig, AuditActorKind, AuditCallMeta, AuditEvent, AuditQueryFilters, AuditStatus, AuditTarget, AuditVisibility, } from "./types.js";
-export { deriveActorKind, isAuditDisabled, normalizeAuditConfig, resolveAuditAttach, shouldRecordAudit, } from "./config.js";
+export { AGENT_AUDIT_CALLERS, deriveActorKind, isAuditDisabled, normalizeAuditConfig, resolveAuditAttach, shouldRecordAudit, } from "./config.js";
 export { redactArgsToJson } from "./redact.js";
 export { ensureAuditTables, insertAuditEvent, queryAuditEvents, queryAuditEventPage, queryAuditApps, getAuditEventById, deleteOldAuditEvents, type AuditEventPage, type AuditReadScope, type AuditTrail, } from "./store.js";
 export { AuditAccessError, resolveAuditReadScope } from "./read-scope.js";

package/dist/audit/index.js

@@ -1,4 +1,4 @@
-export { deriveActorKind, isAuditDisabled, normalizeAuditConfig, resolveAuditAttach, shouldRecordAudit, } from "./config.js";
+export { AGENT_AUDIT_CALLERS, deriveActorKind, isAuditDisabled, normalizeAuditConfig, resolveAuditAttach, shouldRecordAudit, } from "./config.js";
 export { redactArgsToJson } from "./redact.js";
 export { ensureAuditTables, insertAuditEvent, queryAuditEvents, queryAuditEventPage, queryAuditApps, getAuditEventById, deleteOldAuditEvents, } from "./store.js";
 export { AuditAccessError, resolveAuditReadScope } from "./read-scope.js";

package/dist/audit/store.js

@@ -1,5 +1,6 @@
 import { getDbExec } from "../db/client.js";
 import { ensureColumnExists, ensureTableExists, ensureIndexExists, } from "../db/ddl-guard.js";
+import { AGENT_AUDIT_CALLERS } from "./config.js";
 let _initPromise;
 export const AGENT_AUDIT_LOG_CREATE_SQL = `
   CREATE TABLE IF NOT EXISTS agent_audit_log (
@@ -115,13 +116,44 @@ export async function insertAuditEvent(event) {
         ],
     });
 }
+// Rows recorded before outside agents (MCP, WebMCP, A2A) counted as agents
+// stored `human` or `system` for them. Reads classify those by caller here and
+// in `actorKindClause`, so an old row and a filter on it agree without
+// rewriting the append-only log. A `service` row keeps its kind: org service
+// principals mostly call over MCP.
+const LEGACY_AGENT_KINDS = ["human", "system"];
+function readActorKind(storedKind, caller) {
+    return LEGACY_AGENT_KINDS.includes(storedKind) &&
+        AGENT_AUDIT_CALLERS.has(caller)
+        ? "agent"
+        : storedKind;
+}
+function actorKindClause(kind) {
+    const callers = [...AGENT_AUDIT_CALLERS];
+    const agentCaller = `caller IN (${callers.map(() => "?").join(", ")})`;
+    if (kind === "agent") {
+        const legacy = LEGACY_AGENT_KINDS.map(() => "?").join(", ");
+        return {
+            sql: `(actor_kind = ? OR (actor_kind IN (${legacy}) AND ${agentCaller}))`,
+            args: [kind, ...LEGACY_AGENT_KINDS, ...callers],
+        };
+    }
+    if (LEGACY_AGENT_KINDS.includes(kind)) {
+        return {
+            sql: `(actor_kind = ? AND NOT ${agentCaller})`,
+            args: [kind, ...callers],
+        };
+    }
+    return { sql: "actor_kind = ?", args: [kind] };
+}
 function mapRow(row) {
+    const caller = String(row.caller);
     return {
         id: String(row.id),
         createdAt: Number(row.created_at),
         action: String(row.action),
-        caller: String(row.caller),
-        actorKind: row.actor_kind,
+        caller,
+        actorKind: readActorKind(row.actor_kind, caller),
         actorEmail: row.actor_email ?? null,
         orgId: row.org_id ?? null,
         threadId: row.thread_id ?? null,
@@ -230,8 +262,11 @@ async function selectAuditRows(scope, filters, limit) {
         push("target_type = ?", filters.targetType);
     if (filters.targetId)
         push("target_id = ?", filters.targetId);
-    if (filters.actorKind)
-        push("actor_kind = ?", filters.actorKind);
+    if (filters.actorKind) {
+        const clause = actorKindClause(filters.actorKind);
+        where.push(clause.sql);
+        args.push(...clause.args);
+    }
     if (filters.actorEmail)
         push("actor_email = ?", filters.actorEmail);
     if (filters.status)

package/dist/cli/skills.d.ts

@@ -197,6 +197,7 @@ interface SkillsScopePromptContext {
 interface SkillsPlanModePromptContext {
     initialMode: PlanInstallMode;
 }
+export declare function builtInCommandsRootForAgent(agent: string, scope: "project" | "user", baseDir: string): string;
 export declare function parseSkillsArgs(argv: string[]): ParsedSkillsArgs;
 export declare function addAgentNativeSkill(parsed: ParsedSkillsArgs, options?: RunSkillsOptions): Promise<SkillsAddResult>;
 export declare function runSkills(argv: string[], options?: RunSkillsOptions): Promise<void>;

package/dist/cli/skills.js

@@ -984,7 +984,7 @@ function builtInSkillsRootForAgent(agent, scope, baseDir) {
     }
     return path.join(home, ".claude", "skills");
 }
-function builtInCommandsRootForAgent(agent, scope, baseDir) {
+export function builtInCommandsRootForAgent(agent, scope, baseDir) {
     const home = homeDir() ?? baseDir;
     if (scope === "project") {
         if (agent === "codex")