@growthub/cli 0.3.13 → 0.3.15

package/dist/runtime/server/node_modules/@paperclipai/adapter-claude-local/dist/cli/quota-probe.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import { captureClaudeCliUsageText, fetchClaudeCliQuota, fetchClaudeQuota, getQuotaWindows, parseClaudeCliUsageText, readClaudeAuthStatus, readClaudeToken, } from "../server/quota.js";
+function parseArgs(argv) {
+    return {
+        json: argv.includes("--json"),
+        includeRawCli: argv.includes("--raw-cli"),
+        oauthOnly: argv.includes("--oauth-only"),
+        cliOnly: argv.includes("--cli-only"),
+    };
+}
+function stringifyError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.oauthOnly && args.cliOnly) {
+        throw new Error("Choose either --oauth-only or --cli-only, not both.");
+    }
+    const authStatus = await readClaudeAuthStatus();
+    const token = await readClaudeToken();
+    const result = {
+        timestamp: new Date().toISOString(),
+        authStatus,
+        tokenAvailable: token != null,
+    };
+    if (!args.cliOnly) {
+        if (!token) {
+            result.oauth = {
+                ok: false,
+                error: "No Claude OAuth access token found in local credentials files.",
+                windows: [],
+            };
+        }
+        else {
+            try {
+                result.oauth = {
+                    ok: true,
+                    windows: await fetchClaudeQuota(token),
+                };
+            }
+            catch (error) {
+                result.oauth = {
+                    ok: false,
+                    error: stringifyError(error),
+                    windows: [],
+                };
+            }
+        }
+    }
+    if (!args.oauthOnly) {
+        try {
+            const rawCliText = args.includeRawCli ? await captureClaudeCliUsageText() : null;
+            const windows = rawCliText ? parseClaudeCliUsageText(rawCliText) : await fetchClaudeCliQuota();
+            result.cli = rawCliText
+                ? {
+                    ok: true,
+                    windows,
+                    rawText: rawCliText,
+                }
+                : {
+                    ok: true,
+                    windows,
+                };
+        }
+        catch (error) {
+            result.cli = {
+                ok: false,
+                error: stringifyError(error),
+                windows: [],
+            };
+        }
+    }
+    if (!args.oauthOnly && !args.cliOnly) {
+        try {
+            result.aggregated = await getQuotaWindows();
+        }
+        catch (error) {
+            result.aggregated = {
+                ok: false,
+                error: stringifyError(error),
+            };
+        }
+    }
+    const oauthOk = result.oauth?.ok === true;
+    const cliOk = result.cli?.ok === true;
+    const aggregatedOk = result.aggregated?.ok === true;
+    const ok = oauthOk || cliOk || aggregatedOk;
+    if (args.json || process.stdout.isTTY === false) {
+        console.log(JSON.stringify({ ok, ...result }, null, 2));
+    }
+    else {
+        console.log(`timestamp: ${result.timestamp}`);
+        console.log(`auth: ${JSON.stringify(authStatus)}`);
+        console.log(`tokenAvailable: ${token != null}`);
+        if (result.oauth)
+            console.log(`oauth: ${JSON.stringify(result.oauth, null, 2)}`);
+        if (result.cli)
+            console.log(`cli: ${JSON.stringify(result.cli, null, 2)}`);
+        if (result.aggregated)
+            console.log(`aggregated: ${JSON.stringify(result.aggregated, null, 2)}`);
+    }
+    if (!ok)
+        process.exitCode = 1;
+}
+await main();
+//# sourceMappingURL=quota-probe.js.map

package/dist/runtime/server/node_modules/@paperclipai/adapter-claude-local/dist/cli/quota-probe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quota-probe.js","sourceRoot":"","sources":["../../src/cli/quota-probe.ts"],"names":[],"mappings":"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"}

package/dist/runtime/server/node_modules/@paperclipai/adapter-claude-local/dist/index.d.ts

@@ -0,0 +1,8 @@
+export declare const type = "claude_local";
+export declare const label = "Claude Code (local)";
+export declare const models: {
+    id: string;
+    label: string;
+}[];
+export declare const agentConfigurationDoc = "# claude_local agent configuration\n\nAdapter: claude_local\n\nCore fields:\n- cwd (string, optional): default absolute working directory fallback for the agent process (created if missing when possible)\n- instructionsFilePath (string, optional): absolute path to a markdown instructions file injected at runtime\n- model (string, optional): Claude model id\n- effort (string, optional): reasoning effort passed via --effort (low|medium|high)\n- chrome (boolean, optional): pass --chrome when running Claude\n- promptTemplate (string, optional): run prompt template\n- maxTurnsPerRun (number, optional): max turns for one run\n- dangerouslySkipPermissions (boolean, optional): pass --dangerously-skip-permissions to claude\n- command (string, optional): defaults to \"claude\"\n- extraArgs (string[], optional): additional CLI args\n- env (object, optional): KEY=VALUE environment variables\n- workspaceStrategy (object, optional): execution workspace strategy; currently supports { type: \"git_worktree\", baseRef?, branchTemplate?, worktreeParentDir? }\n- workspaceRuntime (object, optional): workspace runtime service intents; local host-managed services are realized before Claude starts and exposed back via context/env\n\nOperational fields:\n- timeoutSec (number, optional): run timeout in seconds\n- graceSec (number, optional): SIGTERM grace period in seconds\n\nNotes:\n- When Paperclip realizes a workspace/runtime for a run, it injects PAPERCLIP_WORKSPACE_* and PAPERCLIP_RUNTIME_* env vars for agent-side tooling.\n";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/server/node_modules/@paperclipai/adapter-claude-local/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,iBAAiB,CAAC;AACnC,eAAO,MAAM,KAAK,wBAAwB,CAAC;AAE3C,eAAO,MAAM,MAAM;;;GAMlB,CAAC;AAEF,eAAO,MAAM,qBAAqB,8/CAyBjC,CAAC"}

package/dist/runtime/server/node_modules/@paperclipai/adapter-claude-local/dist/index.js

@@ -0,0 +1,36 @@
+export const type = "claude_local";
+export const label = "Claude Code (local)";
+export const models = [
+    { id: "claude-opus-4-6", label: "Claude Opus 4.6" },
+    { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
+    { id: "claude-haiku-4-6", label: "Claude Haiku 4.6" },
+    { id: "claude-sonnet-4-5-20250929", label: "Claude Sonnet 4.5" },
+    { id: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5" },
+];
+export const agentConfigurationDoc = `# claude_local agent configuration
+
+Adapter: claude_local
+
+Core fields:
+- cwd (string, optional): default absolute working directory fallback for the agent process (created if missing when possible)
+- instructionsFilePath (string, optional): absolute path to a markdown instructions file injected at runtime
+- model (string, optional): Claude model id
+- effort (string, optional): reasoning effort passed via --effort (low|medium|high)
+- chrome (boolean, optional): pass --chrome when running Claude
+- promptTemplate (string, optional): run prompt template
+- maxTurnsPerRun (number, optional): max turns for one run
+- dangerouslySkipPermissions (boolean, optional): pass --dangerously-skip-permissions to claude
+- command (string, optional): defaults to "claude"
+- extraArgs (string[], optional): additional CLI args
+- env (object, optional): KEY=VALUE environment variables
+- workspaceStrategy (object, optional): execution workspace strategy; currently supports { type: "git_worktree", baseRef?, branchTemplate?, worktreeParentDir? }
+- workspaceRuntime (object, optional): workspace runtime service intents; local host-managed services are realized before Claude starts and exposed back via context/env
+
+Operational fields:
+- timeoutSec (number, optional): run timeout in seconds
+- graceSec (number, optional): SIGTERM grace period in seconds
+
+Notes:
+- When Paperclip realizes a workspace/runtime for a run, it injects PAPERCLIP_WORKSPACE_* and PAPERCLIP_RUNTIME_* env vars for agent-side tooling.
+`;
+//# sourceMappingURL=index.js.map

package/dist/runtime/server/node_modules/@paperclipai/adapter-claude-local/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,IAAI,GAAG,cAAc,CAAC;AACnC,MAAM,CAAC,MAAM,KAAK,GAAG,qBAAqB,CAAC;AAE3C,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,EAAE,EAAE,EAAE,iBAAiB,EAAE,KAAK,EAAE,iBAAiB,EAAE;IACnD,EAAE,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE,mBAAmB,EAAE;IACvD,EAAE,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,kBAAkB,EAAE;IACrD,EAAE,EAAE,EAAE,4BAA4B,EAAE,KAAK,EAAE,mBAAmB,EAAE;IAChE,EAAE,EAAE,EAAE,2BAA2B,EAAE,KAAK,EAAE,kBAAkB,EAAE;CAC/D,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyBpC,CAAC"}

package/dist/runtime/server/node_modules/@paperclipai/adapter-claude-local/dist/server/execute.d.ts

@@ -0,0 +1,18 @@
+import type { AdapterExecutionContext, AdapterExecutionResult } from "@paperclipai/adapter-utils";
+export declare function runClaudeLogin(input: {
+    runId: string;
+    agent: AdapterExecutionContext["agent"];
+    config: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    authToken?: string;
+    onLog?: (stream: "stdout" | "stderr", chunk: string) => Promise<void>;
+}): Promise<{
+    exitCode: number | null;
+    signal: string | null;
+    timedOut: boolean;
+    stdout: string;
+    stderr: string;
+    loginUrl: string | null;
+}>;
+export declare function execute(ctx: AdapterExecutionContext): Promise<AdapterExecutionResult>;
+//# sourceMappingURL=execute.d.ts.map

package/dist/runtime/server/node_modules/@paperclipai/adapter-claude-local/dist/server/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/server/execute.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAuQlG,wBAAsB,cAAc,CAAC,KAAK,EAAE;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE;;;;;;;GA4BA;AAED,wBAAsB,OAAO,CAAC,GAAG,EAAE,uBAAuB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CA0R3F"}

package/dist/runtime/server/node_modules/@paperclipai/adapter-claude-local/dist/server/execute.js

@@ -0,0 +1,453 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { asString, asNumber, asBoolean, asStringArray, parseObject, parseJson, buildPaperclipEnv, joinPromptSections, redactEnvForLogs, ensureAbsoluteDirectory, ensureCommandResolvable, ensurePathInEnv, renderTemplate, runChildProcess, } from "@paperclipai/adapter-utils/server-utils";
+import { parseClaudeStreamJson, describeClaudeFailure, detectClaudeLoginRequired, isClaudeMaxTurnsResult, isClaudeUnknownSessionError, } from "./parse.js";
+const __moduleDir = path.dirname(fileURLToPath(import.meta.url));
+const PAPERCLIP_SKILLS_CANDIDATES = [
+    path.resolve(__moduleDir, "../../skills"), // published: <pkg>/dist/server/ -> <pkg>/skills/
+    path.resolve(__moduleDir, "../../../../../skills"), // dev: src/server/ -> repo root/skills/
+];
+async function resolvePaperclipSkillsDir() {
+    for (const candidate of PAPERCLIP_SKILLS_CANDIDATES) {
+        const isDir = await fs.stat(candidate).then((s) => s.isDirectory()).catch(() => false);
+        if (isDir)
+            return candidate;
+    }
+    return null;
+}
+/**
+ * Create a tmpdir with `.claude/skills/` containing symlinks to skills from
+ * the repo's `skills/` directory, so `--add-dir` makes Claude Code discover
+ * them as proper registered skills.
+ */
+async function buildSkillsDir() {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-skills-"));
+    const target = path.join(tmp, ".claude", "skills");
+    await fs.mkdir(target, { recursive: true });
+    const skillsDir = await resolvePaperclipSkillsDir();
+    if (!skillsDir)
+        return tmp;
+    const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            await fs.symlink(path.join(skillsDir, entry.name), path.join(target, entry.name));
+        }
+    }
+    return tmp;
+}
+function buildLoginResult(input) {
+    return {
+        exitCode: input.proc.exitCode,
+        signal: input.proc.signal,
+        timedOut: input.proc.timedOut,
+        stdout: input.proc.stdout,
+        stderr: input.proc.stderr,
+        loginUrl: input.loginUrl,
+    };
+}
+function hasNonEmptyEnvValue(env, key) {
+    const raw = env[key];
+    return typeof raw === "string" && raw.trim().length > 0;
+}
+function resolveClaudeBillingType(env) {
+    // Claude uses API-key auth when ANTHROPIC_API_KEY is present; otherwise rely on local login/session auth.
+    return hasNonEmptyEnvValue(env, "ANTHROPIC_API_KEY") ? "api" : "subscription";
+}
+async function buildClaudeRuntimeConfig(input) {
+    const { runId, agent, config, context, authToken } = input;
+    const command = asString(config.command, "claude");
+    const workspaceContext = parseObject(context.paperclipWorkspace);
+    const workspaceCwd = asString(workspaceContext.cwd, "");
+    const workspaceSource = asString(workspaceContext.source, "");
+    const workspaceStrategy = asString(workspaceContext.strategy, "");
+    const workspaceId = asString(workspaceContext.workspaceId, "") || null;
+    const workspaceRepoUrl = asString(workspaceContext.repoUrl, "") || null;
+    const workspaceRepoRef = asString(workspaceContext.repoRef, "") || null;
+    const workspaceBranch = asString(workspaceContext.branchName, "") || null;
+    const workspaceWorktreePath = asString(workspaceContext.worktreePath, "") || null;
+    const agentHome = asString(workspaceContext.agentHome, "") || null;
+    const workspaceHints = Array.isArray(context.paperclipWorkspaces)
+        ? context.paperclipWorkspaces.filter((value) => typeof value === "object" && value !== null)
+        : [];
+    const runtimeServiceIntents = Array.isArray(context.paperclipRuntimeServiceIntents)
+        ? context.paperclipRuntimeServiceIntents.filter((value) => typeof value === "object" && value !== null)
+        : [];
+    const runtimeServices = Array.isArray(context.paperclipRuntimeServices)
+        ? context.paperclipRuntimeServices.filter((value) => typeof value === "object" && value !== null)
+        : [];
+    const runtimePrimaryUrl = asString(context.paperclipRuntimePrimaryUrl, "");
+    const configuredCwd = asString(config.cwd, "");
+    const useConfiguredInsteadOfAgentHome = workspaceSource === "agent_home" && configuredCwd.length > 0;
+    const effectiveWorkspaceCwd = useConfiguredInsteadOfAgentHome ? "" : workspaceCwd;
+    const cwd = effectiveWorkspaceCwd || configuredCwd || process.cwd();
+    await ensureAbsoluteDirectory(cwd, { createIfMissing: true });
+    const envConfig = parseObject(config.env);
+    const hasExplicitApiKey = typeof envConfig.PAPERCLIP_API_KEY === "string" && envConfig.PAPERCLIP_API_KEY.trim().length > 0;
+    const env = { ...buildPaperclipEnv(agent) };
+    env.PAPERCLIP_RUN_ID = runId;
+    const wakeTaskId = (typeof context.taskId === "string" && context.taskId.trim().length > 0 && context.taskId.trim()) ||
+        (typeof context.issueId === "string" && context.issueId.trim().length > 0 && context.issueId.trim()) ||
+        null;
+    const wakeReason = typeof context.wakeReason === "string" && context.wakeReason.trim().length > 0
+        ? context.wakeReason.trim()
+        : null;
+    const wakeCommentId = (typeof context.wakeCommentId === "string" && context.wakeCommentId.trim().length > 0 && context.wakeCommentId.trim()) ||
+        (typeof context.commentId === "string" && context.commentId.trim().length > 0 && context.commentId.trim()) ||
+        null;
+    const approvalId = typeof context.approvalId === "string" && context.approvalId.trim().length > 0
+        ? context.approvalId.trim()
+        : null;
+    const approvalStatus = typeof context.approvalStatus === "string" && context.approvalStatus.trim().length > 0
+        ? context.approvalStatus.trim()
+        : null;
+    const linkedIssueIds = Array.isArray(context.issueIds)
+        ? context.issueIds.filter((value) => typeof value === "string" && value.trim().length > 0)
+        : [];
+    if (wakeTaskId) {
+        env.PAPERCLIP_TASK_ID = wakeTaskId;
+    }
+    if (wakeReason) {
+        env.PAPERCLIP_WAKE_REASON = wakeReason;
+    }
+    if (wakeCommentId) {
+        env.PAPERCLIP_WAKE_COMMENT_ID = wakeCommentId;
+    }
+    if (approvalId) {
+        env.PAPERCLIP_APPROVAL_ID = approvalId;
+    }
+    if (approvalStatus) {
+        env.PAPERCLIP_APPROVAL_STATUS = approvalStatus;
+    }
+    if (linkedIssueIds.length > 0) {
+        env.PAPERCLIP_LINKED_ISSUE_IDS = linkedIssueIds.join(",");
+    }
+    if (effectiveWorkspaceCwd) {
+        env.PAPERCLIP_WORKSPACE_CWD = effectiveWorkspaceCwd;
+    }
+    if (workspaceSource) {
+        env.PAPERCLIP_WORKSPACE_SOURCE = workspaceSource;
+    }
+    if (workspaceStrategy) {
+        env.PAPERCLIP_WORKSPACE_STRATEGY = workspaceStrategy;
+    }
+    if (workspaceId) {
+        env.PAPERCLIP_WORKSPACE_ID = workspaceId;
+    }
+    if (workspaceRepoUrl) {
+        env.PAPERCLIP_WORKSPACE_REPO_URL = workspaceRepoUrl;
+    }
+    if (workspaceRepoRef) {
+        env.PAPERCLIP_WORKSPACE_REPO_REF = workspaceRepoRef;
+    }
+    if (workspaceBranch) {
+        env.PAPERCLIP_WORKSPACE_BRANCH = workspaceBranch;
+    }
+    if (workspaceWorktreePath) {
+        env.PAPERCLIP_WORKSPACE_WORKTREE_PATH = workspaceWorktreePath;
+    }
+    if (agentHome) {
+        env.AGENT_HOME = agentHome;
+    }
+    if (workspaceHints.length > 0) {
+        env.PAPERCLIP_WORKSPACES_JSON = JSON.stringify(workspaceHints);
+    }
+    if (runtimeServiceIntents.length > 0) {
+        env.PAPERCLIP_RUNTIME_SERVICE_INTENTS_JSON = JSON.stringify(runtimeServiceIntents);
+    }
+    if (runtimeServices.length > 0) {
+        env.PAPERCLIP_RUNTIME_SERVICES_JSON = JSON.stringify(runtimeServices);
+    }
+    if (runtimePrimaryUrl) {
+        env.PAPERCLIP_RUNTIME_PRIMARY_URL = runtimePrimaryUrl;
+    }
+    for (const [key, value] of Object.entries(envConfig)) {
+        if (typeof value === "string")
+            env[key] = value;
+    }
+    if (!hasExplicitApiKey && authToken) {
+        env.PAPERCLIP_API_KEY = authToken;
+    }
+    const runtimeEnv = ensurePathInEnv({ ...process.env, ...env });
+    await ensureCommandResolvable(command, cwd, runtimeEnv);
+    const timeoutSec = asNumber(config.timeoutSec, 0);
+    const graceSec = asNumber(config.graceSec, 20);
+    const extraArgs = (() => {
+        const fromExtraArgs = asStringArray(config.extraArgs);
+        if (fromExtraArgs.length > 0)
+            return fromExtraArgs;
+        return asStringArray(config.args);
+    })();
+    return {
+        command,
+        cwd,
+        workspaceId,
+        workspaceRepoUrl,
+        workspaceRepoRef,
+        env,
+        timeoutSec,
+        graceSec,
+        extraArgs,
+    };
+}
+export async function runClaudeLogin(input) {
+    const onLog = input.onLog ?? (async () => { });
+    const runtime = await buildClaudeRuntimeConfig({
+        runId: input.runId,
+        agent: input.agent,
+        config: input.config,
+        context: input.context ?? {},
+        authToken: input.authToken,
+    });
+    const proc = await runChildProcess(input.runId, runtime.command, ["login"], {
+        cwd: runtime.cwd,
+        env: runtime.env,
+        timeoutSec: runtime.timeoutSec,
+        graceSec: runtime.graceSec,
+        onLog,
+    });
+    const loginMeta = detectClaudeLoginRequired({
+        parsed: null,
+        stdout: proc.stdout,
+        stderr: proc.stderr,
+    });
+    return buildLoginResult({
+        proc,
+        loginUrl: loginMeta.loginUrl,
+    });
+}
+export async function execute(ctx) {
+    const { runId, agent, runtime, config, context, onLog, onMeta, onSpawn, authToken } = ctx;
+    const promptTemplate = asString(config.promptTemplate, "You are agent {{agent.id}} ({{agent.name}}). Continue your Paperclip work.");
+    const model = asString(config.model, "");
+    const effort = asString(config.effort, "");
+    const chrome = asBoolean(config.chrome, false);
+    const maxTurns = asNumber(config.maxTurnsPerRun, 0);
+    const dangerouslySkipPermissions = asBoolean(config.dangerouslySkipPermissions, false);
+    const instructionsFilePath = asString(config.instructionsFilePath, "").trim();
+    const instructionsFileDir = instructionsFilePath ? `${path.dirname(instructionsFilePath)}/` : "";
+    const commandNotes = instructionsFilePath
+        ? [
+            `Injected agent instructions via --append-system-prompt-file ${instructionsFilePath} (with path directive appended)`,
+        ]
+        : [];
+    const runtimeConfig = await buildClaudeRuntimeConfig({
+        runId,
+        agent,
+        config,
+        context,
+        authToken,
+    });
+    const { command, cwd, workspaceId, workspaceRepoUrl, workspaceRepoRef, env, timeoutSec, graceSec, extraArgs, } = runtimeConfig;
+    const effectiveEnv = Object.fromEntries(Object.entries({ ...process.env, ...env }).filter((entry) => typeof entry[1] === "string"));
+    const billingType = resolveClaudeBillingType(effectiveEnv);
+    const skillsDir = await buildSkillsDir();
+    // When instructionsFilePath is configured, create a combined temp file that
+    // includes both the file content and the path directive, so we only need
+    // --append-system-prompt-file (Claude CLI forbids using both flags together).
+    let effectiveInstructionsFilePath = instructionsFilePath;
+    if (instructionsFilePath) {
+        const instructionsContent = await fs.readFile(instructionsFilePath, "utf-8");
+        const pathDirective = `\nThe above agent instructions were loaded from ${instructionsFilePath}. Resolve any relative file references from ${instructionsFileDir}.`;
+        const combinedPath = path.join(skillsDir, "agent-instructions.md");
+        await fs.writeFile(combinedPath, instructionsContent + pathDirective, "utf-8");
+        effectiveInstructionsFilePath = combinedPath;
+    }
+    const runtimeSessionParams = parseObject(runtime.sessionParams);
+    const runtimeSessionId = asString(runtimeSessionParams.sessionId, runtime.sessionId ?? "");
+    const runtimeSessionCwd = asString(runtimeSessionParams.cwd, "");
+    const canResumeSession = runtimeSessionId.length > 0 &&
+        (runtimeSessionCwd.length === 0 || path.resolve(runtimeSessionCwd) === path.resolve(cwd));
+    const sessionId = canResumeSession ? runtimeSessionId : null;
+    if (runtimeSessionId && !canResumeSession) {
+        await onLog("stdout", `[paperclip] Claude session "${runtimeSessionId}" was saved for cwd "${runtimeSessionCwd}" and will not be resumed in "${cwd}".\n`);
+    }
+    const bootstrapPromptTemplate = asString(config.bootstrapPromptTemplate, "");
+    const templateData = {
+        agentId: agent.id,
+        companyId: agent.companyId,
+        runId,
+        company: { id: agent.companyId },
+        agent,
+        run: { id: runId, source: "on_demand" },
+        context,
+    };
+    const renderedPrompt = renderTemplate(promptTemplate, templateData);
+    const renderedBootstrapPrompt = !sessionId && bootstrapPromptTemplate.trim().length > 0
+        ? renderTemplate(bootstrapPromptTemplate, templateData).trim()
+        : "";
+    const sessionHandoffNote = asString(context.paperclipSessionHandoffMarkdown, "").trim();
+    const prompt = joinPromptSections([
+        renderedBootstrapPrompt,
+        sessionHandoffNote,
+        renderedPrompt,
+    ]);
+    const promptMetrics = {
+        promptChars: prompt.length,
+        bootstrapPromptChars: renderedBootstrapPrompt.length,
+        sessionHandoffChars: sessionHandoffNote.length,
+        heartbeatPromptChars: renderedPrompt.length,
+    };
+    const buildClaudeArgs = (resumeSessionId) => {
+        const args = ["--print", "-", "--output-format", "stream-json", "--verbose"];
+        if (resumeSessionId)
+            args.push("--resume", resumeSessionId);
+        if (dangerouslySkipPermissions)
+            args.push("--dangerously-skip-permissions");
+        if (chrome)
+            args.push("--chrome");
+        if (model)
+            args.push("--model", model);
+        if (effort)
+            args.push("--effort", effort);
+        if (maxTurns > 0)
+            args.push("--max-turns", String(maxTurns));
+        if (effectiveInstructionsFilePath) {
+            args.push("--append-system-prompt-file", effectiveInstructionsFilePath);
+        }
+        args.push("--add-dir", skillsDir);
+        if (extraArgs.length > 0)
+            args.push(...extraArgs);
+        return args;
+    };
+    const parseFallbackErrorMessage = (proc) => {
+        const stderrLine = proc.stderr
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .find(Boolean) ?? "";
+        if ((proc.exitCode ?? 0) === 0) {
+            return "Failed to parse claude JSON output";
+        }
+        return stderrLine
+            ? `Claude exited with code ${proc.exitCode ?? -1}: ${stderrLine}`
+            : `Claude exited with code ${proc.exitCode ?? -1}`;
+    };
+    const runAttempt = async (resumeSessionId) => {
+        const args = buildClaudeArgs(resumeSessionId);
+        if (onMeta) {
+            await onMeta({
+                adapterType: "claude_local",
+                command,
+                cwd,
+                commandArgs: args,
+                commandNotes,
+                env: redactEnvForLogs(env),
+                prompt,
+                promptMetrics,
+                context,
+            });
+        }
+        const proc = await runChildProcess(runId, command, args, {
+            cwd,
+            env,
+            stdin: prompt,
+            timeoutSec,
+            graceSec,
+            onSpawn,
+            onLog,
+        });
+        const parsedStream = parseClaudeStreamJson(proc.stdout);
+        const parsed = parsedStream.resultJson ?? parseJson(proc.stdout);
+        return { proc, parsedStream, parsed };
+    };
+    const toAdapterResult = (attempt, opts) => {
+        const { proc, parsedStream, parsed } = attempt;
+        const loginMeta = detectClaudeLoginRequired({
+            parsed,
+            stdout: proc.stdout,
+            stderr: proc.stderr,
+        });
+        const errorMeta = loginMeta.loginUrl != null
+            ? {
+                loginUrl: loginMeta.loginUrl,
+            }
+            : undefined;
+        if (proc.timedOut) {
+            return {
+                exitCode: proc.exitCode,
+                signal: proc.signal,
+                timedOut: true,
+                errorMessage: `Timed out after ${timeoutSec}s`,
+                errorCode: "timeout",
+                errorMeta,
+                clearSession: Boolean(opts.clearSessionOnMissingSession),
+            };
+        }
+        if (!parsed) {
+            return {
+                exitCode: proc.exitCode,
+                signal: proc.signal,
+                timedOut: false,
+                errorMessage: parseFallbackErrorMessage(proc),
+                errorCode: loginMeta.requiresLogin ? "claude_auth_required" : null,
+                errorMeta,
+                resultJson: {
+                    stdout: proc.stdout,
+                    stderr: proc.stderr,
+                },
+                clearSession: Boolean(opts.clearSessionOnMissingSession),
+            };
+        }
+        const usage = parsedStream.usage ??
+            (() => {
+                const usageObj = parseObject(parsed.usage);
+                return {
+                    inputTokens: asNumber(usageObj.input_tokens, 0),
+                    cachedInputTokens: asNumber(usageObj.cache_read_input_tokens, 0),
+                    outputTokens: asNumber(usageObj.output_tokens, 0),
+                };
+            })();
+        const resolvedSessionId = parsedStream.sessionId ??
+            (asString(parsed.session_id, opts.fallbackSessionId ?? "") || opts.fallbackSessionId);
+        const resolvedSessionParams = resolvedSessionId
+            ? {
+                sessionId: resolvedSessionId,
+                cwd,
+                ...(workspaceId ? { workspaceId } : {}),
+                ...(workspaceRepoUrl ? { repoUrl: workspaceRepoUrl } : {}),
+                ...(workspaceRepoRef ? { repoRef: workspaceRepoRef } : {}),
+            }
+            : null;
+        const clearSessionForMaxTurns = isClaudeMaxTurnsResult(parsed);
+        return {
+            exitCode: proc.exitCode,
+            signal: proc.signal,
+            timedOut: false,
+            errorMessage: (proc.exitCode ?? 0) === 0
+                ? null
+                : describeClaudeFailure(parsed) ?? `Claude exited with code ${proc.exitCode ?? -1}`,
+            errorCode: loginMeta.requiresLogin ? "claude_auth_required" : null,
+            errorMeta,
+            usage,
+            sessionId: resolvedSessionId,
+            sessionParams: resolvedSessionParams,
+            sessionDisplayId: resolvedSessionId,
+            provider: "anthropic",
+            biller: "anthropic",
+            model: parsedStream.model || asString(parsed.model, model),
+            billingType,
+            costUsd: parsedStream.costUsd ?? asNumber(parsed.total_cost_usd, 0),
+            resultJson: parsed,
+            summary: parsedStream.summary || asString(parsed.result, ""),
+            clearSession: clearSessionForMaxTurns || Boolean(opts.clearSessionOnMissingSession && !resolvedSessionId),
+        };
+    };
+    try {
+        const initial = await runAttempt(sessionId ?? null);
+        if (sessionId &&
+            !initial.proc.timedOut &&
+            (initial.proc.exitCode ?? 0) !== 0 &&
+            initial.parsed &&
+            isClaudeUnknownSessionError(initial.parsed)) {
+            await onLog("stdout", `[paperclip] Claude resume session "${sessionId}" is unavailable; retrying with a fresh session.\n`);
+            const retry = await runAttempt(null);
+            return toAdapterResult(retry, { fallbackSessionId: null, clearSessionOnMissingSession: true });
+        }
+        return toAdapterResult(initial, { fallbackSessionId: runtimeSessionId || runtime.sessionId });
+    }
+    finally {
+        fs.rm(skillsDir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+//# sourceMappingURL=execute.js.map