@paperclipai/adapter-grok-local 0.3.1

package/dist/cli/format-event.d.ts

@@ -0,0 +1,2 @@
+export declare function printGrokStreamEvent(raw: string, _debug: boolean): void;
+//# sourceMappingURL=format-event.d.ts.map

package/dist/cli/format-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-event.d.ts","sourceRoot":"","sources":["../../src/cli/format-event.ts"],"names":[],"mappings":"AAWA,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CA+CvE"}

package/dist/cli/format-event.js

@@ -0,0 +1,55 @@
+import pc from "picocolors";
+function asRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    return value;
+}
+function asString(value, fallback = "") {
+    return typeof value === "string" ? value : fallback;
+}
+export function printGrokStreamEvent(raw, _debug) {
+    const line = raw.trim();
+    if (!line)
+        return;
+    let parsed = null;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        console.log(line);
+        return;
+    }
+    const type = asString(parsed.type).trim();
+    if (type === "thought") {
+        const text = asString(parsed.data);
+        if (text)
+            console.log(pc.gray(`thinking: ${text}`));
+        return;
+    }
+    if (type === "text") {
+        const text = asString(parsed.data);
+        if (text)
+            console.log(pc.green(`assistant: ${text}`));
+        return;
+    }
+    if (type === "end") {
+        const stopReason = asString(parsed.stopReason);
+        const sessionId = asString(parsed.sessionId);
+        const details = [stopReason ? `stopReason=${stopReason}` : "", sessionId ? `session=${sessionId}` : ""]
+            .filter(Boolean)
+            .join(" ");
+        console.log(pc.blue(`Grok run completed${details ? ` (${details})` : ""}`));
+        return;
+    }
+    if (type === "error") {
+        const text = asString(parsed.data) ||
+            asString(parsed.message) ||
+            asString(parsed.error) ||
+            "Grok error";
+        console.log(pc.red(`error: ${text}`));
+        return;
+    }
+    const payload = asRecord(parsed);
+    console.log(pc.gray(`event: ${type || "unknown"} ${payload ? JSON.stringify(payload) : line}`));
+}
+//# sourceMappingURL=format-event.js.map

package/dist/cli/format-event.js.map

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

package/dist/cli/format-event.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=format-event.test.d.ts.map

package/dist/cli/format-event.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-event.test.d.ts","sourceRoot":"","sources":["../../src/cli/format-event.test.ts"],"names":[],"mappings":""}

package/dist/cli/format-event.test.js

@@ -0,0 +1,19 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { printGrokStreamEvent } from "./format-event.js";
+describe("printGrokStreamEvent", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => { });
+    afterEach(() => {
+        spy.mockClear();
+    });
+    it("prints thought/text/end events", () => {
+        printGrokStreamEvent(JSON.stringify({ type: "thought", data: "Plan" }), false);
+        printGrokStreamEvent(JSON.stringify({ type: "text", data: "hello" }), false);
+        printGrokStreamEvent(JSON.stringify({ type: "end", stopReason: "EndTurn", sessionId: "sess-1" }), false);
+        expect(spy.mock.calls.flat()).toEqual(expect.arrayContaining([
+            expect.stringContaining("thinking: Plan"),
+            expect.stringContaining("assistant: hello"),
+            expect.stringContaining("Grok run completed"),
+        ]));
+    });
+});
+//# sourceMappingURL=format-event.test.js.map

package/dist/cli/format-event.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-event.test.js","sourceRoot":"","sources":["../../src/cli/format-event.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,QAAQ,CAAC,sBAAsB,EAAE,GAAG,EAAE;IACpC,MAAM,GAAG,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IAElE,SAAS,CAAC,GAAG,EAAE;QACb,GAAG,CAAC,SAAS,EAAE,CAAC;IAClB,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QACxC,oBAAoB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;QAC/E,oBAAoB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;QAC7E,oBAAoB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;QAEzG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CACnC,MAAM,CAAC,eAAe,CAAC;YACrB,MAAM,CAAC,gBAAgB,CAAC,gBAAgB,CAAC;YACzC,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,CAAC;YAC3C,MAAM,CAAC,gBAAgB,CAAC,oBAAoB,CAAC;SAC9C,CAAC,CACH,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+export { printGrokStreamEvent } from "./format-event.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/cli/index.js

@@ -0,0 +1,2 @@
+export { printGrokStreamEvent } from "./format-event.js";
+//# sourceMappingURL=index.js.map

package/dist/cli/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export declare const type = "grok_local";
+export declare const label = "Grok Build (local)";
+export declare const DEFAULT_GROK_LOCAL_MODEL = "grok-build";
+export declare const models: {
+    id: string;
+    label: string;
+}[];
+export declare const agentConfigurationDoc = "# grok_local agent configuration\n\nAdapter: grok_local\n\nUse when:\n- You want Paperclip to run the native Grok Build CLI locally on the host machine\n- You want resumable Grok sessions across heartbeats via `--resume`\n- You want Paperclip-managed instructions and skills staged into the execution workspace using Grok's native discovery paths (`Agents.md` and `.claude/skills`)\n\nDon't use when:\n- You need a webhook-style external invocation (use http or openclaw_gateway)\n- You only need a one-shot script without an AI coding agent loop (use process)\n- Grok CLI is not installed or authenticated on the machine that runs Paperclip\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. Paperclip stages it into the execution workspace as `Agents.md` when safe, otherwise falls back to `--rules @file`\n- promptTemplate (string, optional): run prompt template\n- model (string, optional): Grok model id. Defaults to grok-build.\n- permissionMode (string, optional): Grok permission mode. Defaults to `dontAsk`\n- reasoningEffort (string, optional): Grok reasoning effort passed via `--reasoning-effort`\n- maxTurns (number, optional): maximum agent turns for the run\n- command (string, optional): defaults to \"grok\"\n- extraArgs (string[], optional): additional CLI args\n- env (object, optional): KEY=VALUE environment variables\n\nOperational fields:\n- timeoutSec (number, optional): run timeout in seconds\n- graceSec (number, optional): SIGTERM grace period in seconds\n\nNotes:\n- Runs use `grok --single` with `--output-format streaming-json`.\n- Sessions resume with `--resume <sessionId>` when the saved session cwd matches the current cwd.\n- Paperclip stages desired runtime skills into `.claude/skills` inside the execution workspace so Grok discovers them as project skills.\n- Use `grok models` to inspect authentication and available models on the host.\n";
+//# sourceMappingURL=index.d.ts.map

package/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,eAAe,CAAC;AACjC,eAAO,MAAM,KAAK,uBAAuB,CAAC;AAE1C,eAAO,MAAM,wBAAwB,eAAe,CAAC;AAErD,eAAO,MAAM,MAAM;;;GAElB,CAAC;AAEF,eAAO,MAAM,qBAAqB,ohEAmCjC,CAAC"}

package/dist/index.js

@@ -0,0 +1,43 @@
+export const type = "grok_local";
+export const label = "Grok Build (local)";
+export const DEFAULT_GROK_LOCAL_MODEL = "grok-build";
+export const models = [
+    { id: DEFAULT_GROK_LOCAL_MODEL, label: DEFAULT_GROK_LOCAL_MODEL },
+];
+export const agentConfigurationDoc = `# grok_local agent configuration
+
+Adapter: grok_local
+
+Use when:
+- You want Paperclip to run the native Grok Build CLI locally on the host machine
+- You want resumable Grok sessions across heartbeats via \`--resume\`
+- You want Paperclip-managed instructions and skills staged into the execution workspace using Grok's native discovery paths (\`Agents.md\` and \`.claude/skills\`)
+
+Don't use when:
+- You need a webhook-style external invocation (use http or openclaw_gateway)
+- You only need a one-shot script without an AI coding agent loop (use process)
+- Grok CLI is not installed or authenticated on the machine that runs Paperclip
+
+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. Paperclip stages it into the execution workspace as \`Agents.md\` when safe, otherwise falls back to \`--rules @file\`
+- promptTemplate (string, optional): run prompt template
+- model (string, optional): Grok model id. Defaults to grok-build.
+- permissionMode (string, optional): Grok permission mode. Defaults to \`dontAsk\`
+- reasoningEffort (string, optional): Grok reasoning effort passed via \`--reasoning-effort\`
+- maxTurns (number, optional): maximum agent turns for the run
+- command (string, optional): defaults to "grok"
+- extraArgs (string[], optional): additional CLI args
+- env (object, optional): KEY=VALUE environment variables
+
+Operational fields:
+- timeoutSec (number, optional): run timeout in seconds
+- graceSec (number, optional): SIGTERM grace period in seconds
+
+Notes:
+- Runs use \`grok --single\` with \`--output-format streaming-json\`.
+- Sessions resume with \`--resume <sessionId>\` when the saved session cwd matches the current cwd.
+- Paperclip stages desired runtime skills into \`.claude/skills\` inside the execution workspace so Grok discovers them as project skills.
+- Use \`grok models\` to inspect authentication and available models on the host.
+`;
+//# sourceMappingURL=index.js.map

package/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,YAAY,CAAC;AACjC,MAAM,CAAC,MAAM,KAAK,GAAG,oBAAoB,CAAC;AAE1C,MAAM,CAAC,MAAM,wBAAwB,GAAG,YAAY,CAAC;AAErD,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,EAAE,EAAE,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,EAAE;CAClE,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCpC,CAAC"}

package/dist/server/execute.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterExecutionContext, AdapterExecutionResult } from "@paperclipai/adapter-utils";
+export declare function execute(ctx: AdapterExecutionContext): Promise<AdapterExecutionResult>;
+//# sourceMappingURL=execute.d.ts.map

package/dist/server/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/server/execute.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AA2LlG,wBAAsB,OAAO,CAAC,GAAG,EAAE,uBAAuB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAwY3F"}

package/dist/server/execute.js

@@ -0,0 +1,466 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { adapterExecutionTargetIsRemote, adapterExecutionTargetRemoteCwd, adapterExecutionTargetSessionIdentity, adapterExecutionTargetSessionMatches, describeAdapterExecutionTarget, ensureAdapterExecutionTargetCommandResolvable, ensureAdapterExecutionTargetRuntimeCommandInstalled, overrideAdapterExecutionTargetRemoteCwd, prepareAdapterExecutionTargetRuntime, readAdapterExecutionTarget, resolveAdapterExecutionTargetCommandForLogs, resolveAdapterExecutionTargetTimeoutSec, runAdapterExecutionTargetProcess, } from "@paperclipai/adapter-utils/execution-target";
+import { asBoolean, asNumber, asString, asStringArray, buildInvocationEnvForLogs, buildPaperclipEnv, ensureAbsoluteDirectory, ensurePathInEnv, joinPromptSections, materializePaperclipSkillCopy, parseObject, readPaperclipIssueWorkModeFromContext, readPaperclipRuntimeSkillEntries, renderTemplate, renderPaperclipWakePrompt, resolvePaperclipDesiredSkillNames, stringifyPaperclipWakePayload, refreshPaperclipWorkspaceEnvForExecution, DEFAULT_PAPERCLIP_AGENT_PROMPT_TEMPLATE, } from "@paperclipai/adapter-utils/server-utils";
+import { DEFAULT_GROK_LOCAL_MODEL } from "../index.js";
+import { isGrokUnknownSessionError, parseGrokJsonl } from "./parse.js";
+const __moduleDir = path.dirname(fileURLToPath(import.meta.url));
+function firstNonEmptyLine(text) {
+    return (text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean) ?? "");
+}
+function hasNonEmptyEnvValue(env, key) {
+    const raw = env[key];
+    return typeof raw === "string" && raw.trim().length > 0;
+}
+function renderPaperclipEnvNote(env) {
+    const paperclipKeys = Object.keys(env)
+        .filter((key) => key.startsWith("PAPERCLIP_"))
+        .sort();
+    if (paperclipKeys.length === 0)
+        return "";
+    return [
+        "Paperclip runtime note:",
+        `The following PAPERCLIP_* environment variables are available in this run: ${paperclipKeys.join(", ")}`,
+        "Do not assume these variables are missing without checking your shell environment.",
+        "",
+        "",
+    ].join("\n");
+}
+function renderApiAccessNote(env) {
+    if (!hasNonEmptyEnvValue(env, "PAPERCLIP_API_URL") || !hasNonEmptyEnvValue(env, "PAPERCLIP_API_KEY"))
+        return "";
+    return [
+        "Paperclip API access note:",
+        "Use shell commands with curl to make Paperclip API requests when needed.",
+        "Include X-Paperclip-Run-Id on mutating requests.",
+        "",
+        "",
+    ].join("\n");
+}
+async function pathExists(candidate) {
+    return fs.access(candidate).then(() => true).catch(() => false);
+}
+async function stageGrokProjectAssets(input) {
+    const cleanup = [];
+    const ensureCleanupDir = (candidate) => {
+        cleanup.push({ kind: "dir", path: candidate });
+    };
+    const ensureCleanupFile = (candidate) => {
+        cleanup.push({ kind: "file", path: candidate });
+    };
+    let stagedInstructionsPath = null;
+    let rulesFilePath = null;
+    let stagedSkillsCount = 0;
+    const instructionsTarget = path.join(input.cwd, "Agents.md");
+    if (input.instructionsFilePath) {
+        if (!await pathExists(instructionsTarget)) {
+            await fs.copyFile(input.instructionsFilePath, instructionsTarget);
+            ensureCleanupFile(instructionsTarget);
+            stagedInstructionsPath = instructionsTarget;
+        }
+        else if (path.resolve(instructionsTarget) !== path.resolve(input.instructionsFilePath)) {
+            rulesFilePath = input.instructionsFilePath;
+            await input.onLog("stdout", `[paperclip] Grok workspace already contains ${instructionsTarget}; using --rules @${input.instructionsFilePath} instead of overwriting it.\n`);
+        }
+    }
+    else {
+        const canonicalAgents = path.join(input.cwd, "AGENTS.md");
+        if (!await pathExists(instructionsTarget) && await pathExists(canonicalAgents)) {
+            await fs.copyFile(canonicalAgents, instructionsTarget);
+            ensureCleanupFile(instructionsTarget);
+            stagedInstructionsPath = instructionsTarget;
+        }
+    }
+    const desiredSet = new Set(input.desiredSkillNames);
+    const selectedSkills = input.skillEntries.filter((entry) => desiredSet.has(entry.key));
+    if (selectedSkills.length > 0) {
+        const claudeDir = path.join(input.cwd, ".claude");
+        const skillsRoot = path.join(claudeDir, "skills");
+        if (!await pathExists(claudeDir)) {
+            await fs.mkdir(claudeDir, { recursive: true });
+            ensureCleanupDir(claudeDir);
+        }
+        if (!await pathExists(skillsRoot)) {
+            await fs.mkdir(skillsRoot, { recursive: true });
+            ensureCleanupDir(skillsRoot);
+        }
+        for (const skill of selectedSkills) {
+            const target = path.join(skillsRoot, skill.runtimeName);
+            if (await pathExists(target)) {
+                await input.onLog("stdout", `[paperclip] Grok skill target already exists at ${target}; leaving it unchanged.\n`);
+                continue;
+            }
+            await materializePaperclipSkillCopy(skill.source, target);
+            ensureCleanupDir(target);
+            stagedSkillsCount += 1;
+        }
+    }
+    return {
+        stagedSkillsCount,
+        stagedInstructionsPath,
+        rulesFilePath,
+        cleanup: async () => {
+            for (const entry of [...cleanup].reverse()) {
+                if (entry.kind === "file") {
+                    await fs.rm(entry.path, { force: true }).catch(() => undefined);
+                    continue;
+                }
+                await fs.rm(entry.path, { recursive: true, force: true }).catch(() => undefined);
+            }
+        },
+    };
+}
+function resolveBillingType(env) {
+    return hasNonEmptyEnvValue(env, "XAI_API_KEY") ? "api" : "subscription";
+}
+export async function execute(ctx) {
+    const { runId, agent, runtime, config, context, onLog, onMeta, onSpawn, authToken } = ctx;
+    const executionTarget = readAdapterExecutionTarget({
+        executionTarget: ctx.executionTarget,
+        legacyRemoteExecution: ctx.executionTransport?.remoteExecution,
+    });
+    const executionTargetIsRemote = adapterExecutionTargetIsRemote(executionTarget);
+    const promptTemplate = asString(config.promptTemplate, DEFAULT_PAPERCLIP_AGENT_PROMPT_TEMPLATE);
+    const command = asString(config.command, "grok");
+    const model = asString(config.model, DEFAULT_GROK_LOCAL_MODEL).trim();
+    const permissionMode = asString(config.permissionMode, "dontAsk").trim() || "dontAsk";
+    const reasoningEffort = asString(config.reasoningEffort, "").trim();
+    const maxTurns = asNumber(config.maxTurns, 0);
+    const alwaysApprove = asBoolean(config.alwaysApprove, true);
+    const disableWebSearch = asBoolean(config.disableWebSearch, true);
+    const workspaceContext = parseObject(context.paperclipWorkspace);
+    const workspaceCwd = asString(workspaceContext.cwd, "");
+    const workspaceSource = asString(workspaceContext.source, "");
+    const workspaceId = asString(workspaceContext.workspaceId, "");
+    const workspaceRepoUrl = asString(workspaceContext.repoUrl, "");
+    const workspaceRepoRef = asString(workspaceContext.repoRef, "");
+    const agentHome = asString(workspaceContext.agentHome, "");
+    const workspaceHints = Array.isArray(context.paperclipWorkspaces)
+        ? context.paperclipWorkspaces.filter((value) => typeof value === "object" && value !== null)
+        : [];
+    const configuredCwd = asString(config.cwd, "");
+    const useConfiguredInsteadOfAgentHome = workspaceSource === "agent_home" && configuredCwd.length > 0;
+    const effectiveWorkspaceCwd = useConfiguredInsteadOfAgentHome ? "" : workspaceCwd;
+    const cwd = effectiveWorkspaceCwd || configuredCwd || process.cwd();
+    let effectiveExecutionCwd = adapterExecutionTargetRemoteCwd(executionTarget, cwd);
+    await ensureAbsoluteDirectory(cwd, { createIfMissing: true });
+    const grokSkillEntries = await readPaperclipRuntimeSkillEntries(config, __moduleDir);
+    const desiredGrokSkillNames = resolvePaperclipDesiredSkillNames(config, grokSkillEntries);
+    const instructionsFilePath = asString(config.instructionsFilePath, "").trim();
+    const stagedAssets = await stageGrokProjectAssets({
+        cwd,
+        instructionsFilePath,
+        skillEntries: grokSkillEntries,
+        desiredSkillNames: desiredGrokSkillNames,
+        onLog,
+    });
+    let restoreRemoteWorkspace = null;
+    try {
+        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)
+            : [];
+        const wakePayloadJson = stringifyPaperclipWakePayload(context.paperclipWake);
+        const issueWorkMode = readPaperclipIssueWorkModeFromContext(context);
+        if (wakeTaskId)
+            env.PAPERCLIP_TASK_ID = wakeTaskId;
+        if (issueWorkMode)
+            env.PAPERCLIP_ISSUE_WORK_MODE = issueWorkMode;
+        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 (wakePayloadJson)
+            env.PAPERCLIP_WAKE_PAYLOAD_JSON = wakePayloadJson;
+        refreshPaperclipWorkspaceEnvForExecution({
+            env,
+            envConfig,
+            workspaceCwd: effectiveWorkspaceCwd,
+            workspaceSource,
+            workspaceId,
+            workspaceRepoUrl,
+            workspaceRepoRef,
+            workspaceHints,
+            agentHome,
+            executionTargetIsRemote,
+            executionCwd: effectiveExecutionCwd,
+        });
+        if (!hasExplicitApiKey && authToken) {
+            env.PAPERCLIP_API_KEY = authToken;
+        }
+        const timeoutSec = resolveAdapterExecutionTargetTimeoutSec(executionTarget, asNumber(config.timeoutSec, 0));
+        const graceSec = asNumber(config.graceSec, 20);
+        await ensureAdapterExecutionTargetRuntimeCommandInstalled({
+            runId,
+            target: executionTarget,
+            installCommand: ctx.runtimeCommandSpec?.installCommand,
+            detectCommand: ctx.runtimeCommandSpec?.detectCommand,
+            cwd,
+            env,
+            timeoutSec,
+            graceSec,
+            onLog,
+        });
+        if (executionTargetIsRemote) {
+            await onLog("stdout", `[paperclip] Syncing Grok workspace to ${describeAdapterExecutionTarget(executionTarget)}.\n`);
+            const preparedExecutionTargetRuntime = await prepareAdapterExecutionTargetRuntime({
+                runId,
+                target: executionTarget,
+                adapterKey: "grok",
+                workspaceLocalDir: cwd,
+                timeoutSec,
+                installCommand: ctx.runtimeCommandSpec?.installCommand ?? null,
+                detectCommand: ctx.runtimeCommandSpec?.detectCommand ?? command,
+            });
+            restoreRemoteWorkspace = () => preparedExecutionTargetRuntime.restoreWorkspace();
+            effectiveExecutionCwd = preparedExecutionTargetRuntime.workspaceRemoteDir ?? effectiveExecutionCwd;
+            refreshPaperclipWorkspaceEnvForExecution({
+                env,
+                envConfig,
+                workspaceCwd: effectiveWorkspaceCwd,
+                workspaceSource,
+                workspaceId,
+                workspaceRepoUrl,
+                workspaceRepoRef,
+                workspaceHints,
+                agentHome,
+                executionTargetIsRemote,
+                executionCwd: effectiveExecutionCwd,
+            });
+        }
+        const runtimeExecutionTarget = overrideAdapterExecutionTargetRemoteCwd(executionTarget, effectiveExecutionCwd);
+        const effectiveEnv = Object.fromEntries(Object.entries({ ...process.env, ...env }).filter((entry) => typeof entry[1] === "string"));
+        const runtimeEnv = ensurePathInEnv(effectiveEnv);
+        await ensureAdapterExecutionTargetCommandResolvable(command, executionTarget, cwd, runtimeEnv, {
+            installCommand: ctx.runtimeCommandSpec?.installCommand ?? null,
+            timeoutSec,
+        });
+        const resolvedCommand = await resolveAdapterExecutionTargetCommandForLogs(command, executionTarget, cwd, runtimeEnv);
+        const loggedEnv = buildInvocationEnvForLogs(env, {
+            runtimeEnv,
+            includeRuntimeKeys: ["HOME"],
+            resolvedCommand,
+        });
+        const billingType = resolveBillingType(effectiveEnv);
+        const runtimeSessionParams = parseObject(runtime.sessionParams);
+        const runtimeSessionId = asString(runtimeSessionParams.sessionId, runtime.sessionId ?? "");
+        const runtimeSessionCwd = asString(runtimeSessionParams.cwd, "");
+        const runtimeRemoteExecution = parseObject(runtimeSessionParams.remoteExecution);
+        const canResumeSession = runtimeSessionId.length > 0 &&
+            (runtimeSessionCwd.length === 0 || path.resolve(runtimeSessionCwd) === path.resolve(effectiveExecutionCwd)) &&
+            adapterExecutionTargetSessionMatches(runtimeRemoteExecution, runtimeExecutionTarget);
+        const sessionId = canResumeSession ? runtimeSessionId : null;
+        if (executionTargetIsRemote && runtimeSessionId && !canResumeSession) {
+            await onLog("stdout", `[paperclip] Grok session "${runtimeSessionId}" does not match the current remote execution identity and will not be resumed in "${effectiveExecutionCwd}". Starting a fresh remote session.\n`);
+        }
+        else if (runtimeSessionId && !canResumeSession) {
+            await onLog("stdout", `[paperclip] Grok session "${runtimeSessionId}" was saved for cwd "${runtimeSessionCwd}" and will not be resumed in "${effectiveExecutionCwd}".\n`);
+        }
+        const commandNotes = (() => {
+            const notes = ["Prompt is passed to Grok via --single in headless mode."];
+            if (alwaysApprove)
+                notes.push("Added --always-approve for unattended execution.");
+            if (stagedAssets.stagedInstructionsPath) {
+                notes.push(`Staged project instructions at ${stagedAssets.stagedInstructionsPath} for native Grok discovery.`);
+            }
+            if (stagedAssets.rulesFilePath) {
+                notes.push(`Applied fallback instructions via --rules @${stagedAssets.rulesFilePath}.`);
+            }
+            if (stagedAssets.stagedSkillsCount > 0) {
+                notes.push(`Staged ${stagedAssets.stagedSkillsCount} Paperclip skill(s) into .claude/skills for native Grok discovery.`);
+            }
+            return notes;
+        })();
+        const templateData = {
+            agentId: agent.id,
+            companyId: agent.companyId,
+            runId,
+            company: { id: agent.companyId },
+            agent,
+            run: { id: runId, source: "on_demand" },
+            context,
+        };
+        const wakePrompt = renderPaperclipWakePrompt(context.paperclipWake, { resumedSession: Boolean(sessionId) });
+        const shouldUseResumeDeltaPrompt = Boolean(sessionId) && wakePrompt.length > 0;
+        const renderedPrompt = shouldUseResumeDeltaPrompt ? "" : renderTemplate(promptTemplate, templateData);
+        const sessionHandoffNote = asString(context.paperclipSessionHandoffMarkdown, "").trim();
+        const paperclipEnvNote = renderPaperclipEnvNote(env);
+        const apiAccessNote = renderApiAccessNote(env);
+        const prompt = joinPromptSections([
+            wakePrompt,
+            sessionHandoffNote,
+            paperclipEnvNote,
+            apiAccessNote,
+            renderedPrompt,
+        ]);
+        const promptMetrics = {
+            promptChars: prompt.length,
+            wakePromptChars: wakePrompt.length,
+            sessionHandoffChars: sessionHandoffNote.length,
+            runtimeNoteChars: paperclipEnvNote.length + apiAccessNote.length,
+            heartbeatPromptChars: renderedPrompt.length,
+        };
+        const buildArgs = (resumeSessionId) => {
+            const args = ["--cwd", effectiveExecutionCwd, "--output-format", "streaming-json"];
+            if (resumeSessionId)
+                args.push("--resume", resumeSessionId);
+            if (model && model !== DEFAULT_GROK_LOCAL_MODEL)
+                args.push("--model", model);
+            if (reasoningEffort)
+                args.push("--reasoning-effort", reasoningEffort);
+            if (maxTurns > 0)
+                args.push("--max-turns", String(maxTurns));
+            if (permissionMode)
+                args.push("--permission-mode", permissionMode);
+            if (alwaysApprove)
+                args.push("--always-approve");
+            if (disableWebSearch)
+                args.push("--disable-web-search");
+            if (stagedAssets.rulesFilePath)
+                args.push("--rules", `@${stagedAssets.rulesFilePath}`);
+            const extraArgs = (() => {
+                const fromExtraArgs = asStringArray(config.extraArgs);
+                if (fromExtraArgs.length > 0)
+                    return fromExtraArgs;
+                return asStringArray(config.args);
+            })();
+            if (extraArgs.length > 0)
+                args.push(...extraArgs);
+            args.push("--single", prompt);
+            return args;
+        };
+        const runAttempt = async (resumeSessionId) => {
+            const args = buildArgs(resumeSessionId);
+            if (onMeta) {
+                await onMeta({
+                    adapterType: "grok_local",
+                    command: resolvedCommand,
+                    cwd: effectiveExecutionCwd,
+                    commandNotes,
+                    commandArgs: args.map((value, index) => (index === args.length - 1 ? `<prompt ${prompt.length} chars>` : value)),
+                    env: loggedEnv,
+                    prompt,
+                    promptMetrics,
+                    context,
+                });
+            }
+            const proc = await runAdapterExecutionTargetProcess(runId, runtimeExecutionTarget, command, args, {
+                cwd,
+                env,
+                timeoutSec,
+                graceSec,
+                onSpawn,
+                onLog,
+            });
+            return {
+                proc,
+                parsed: parseGrokJsonl(proc.stdout),
+            };
+        };
+        const toResult = (attempt, clearSessionOnMissingSession = false, isRetry = false) => {
+            if (attempt.proc.timedOut) {
+                return {
+                    exitCode: attempt.proc.exitCode,
+                    signal: attempt.proc.signal,
+                    timedOut: true,
+                    errorMessage: `Timed out after ${timeoutSec}s`,
+                    clearSession: clearSessionOnMissingSession,
+                };
+            }
+            const failed = (attempt.proc.exitCode ?? 0) !== 0;
+            const parsedError = typeof attempt.parsed.errorMessage === "string" ? attempt.parsed.errorMessage.trim() : "";
+            const stderrLine = firstNonEmptyLine(attempt.proc.stderr);
+            const fallbackErrorMessage = parsedError ||
+                stderrLine ||
+                `Grok exited with code ${attempt.proc.exitCode ?? -1}`;
+            const canFallbackToRuntimeSession = !isRetry;
+            const resolvedSessionId = attempt.parsed.sessionId
+                ?? (canFallbackToRuntimeSession ? (runtimeSessionId ?? runtime.sessionId ?? null) : null);
+            const resolvedSessionParams = resolvedSessionId
+                ? {
+                    sessionId: resolvedSessionId,
+                    cwd: effectiveExecutionCwd,
+                    ...(workspaceId ? { workspaceId } : {}),
+                    ...(workspaceRepoUrl ? { repoUrl: workspaceRepoUrl } : {}),
+                    ...(workspaceRepoRef ? { repoRef: workspaceRepoRef } : {}),
+                    ...(executionTargetIsRemote
+                        ? {
+                            remoteExecution: adapterExecutionTargetSessionIdentity(runtimeExecutionTarget),
+                        }
+                        : {}),
+                }
+                : null;
+            return {
+                exitCode: attempt.proc.exitCode,
+                signal: attempt.proc.signal,
+                timedOut: false,
+                errorMessage: failed ? fallbackErrorMessage : null,
+                usage: {
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cachedInputTokens: 0,
+                },
+                sessionId: resolvedSessionId,
+                sessionParams: resolvedSessionParams,
+                sessionDisplayId: resolvedSessionId,
+                provider: "xai",
+                biller: billingType === "api" ? "xai" : "grok",
+                model,
+                billingType,
+                costUsd: null,
+                resultJson: {
+                    stopReason: attempt.parsed.stopReason,
+                    requestId: attempt.parsed.requestId,
+                    ...(failed ? { stderr: attempt.proc.stderr } : {}),
+                },
+                summary: attempt.parsed.summary,
+                clearSession: Boolean(clearSessionOnMissingSession && !resolvedSessionId),
+            };
+        };
+        const initial = await runAttempt(sessionId);
+        if (sessionId &&
+            !initial.proc.timedOut &&
+            (initial.proc.exitCode ?? 0) !== 0 &&
+            isGrokUnknownSessionError(initial.proc.stdout, initial.proc.stderr)) {
+            await onLog("stdout", `[paperclip] Grok resume session "${sessionId}" is unavailable; retrying with a fresh session.\n`);
+            const retry = await runAttempt(null);
+            return toResult(retry, true, true);
+        }
+        return toResult(initial);
+    }
+    finally {
+        await Promise.all([
+            restoreRemoteWorkspace?.(),
+            stagedAssets.cleanup(),
+        ]);
+    }
+}
+//# sourceMappingURL=execute.js.map