@proagentstore/cli 0.4.77 → 0.4.79

package/dist/browser-runner/local-artifact/runtime.js

@@ -0,0 +1,418 @@
+/**
+ * Local artifact generation on the runner (#956) — the Application Tailor's hands.
+ *
+ * One run = one Codex or Claude Code process, signed in on this machine, that turns ONE approved
+ * job lead plus the owner's own source files into a tailored résumé and cover letter. No browser,
+ * no repository, no provider API key. The runtime, not the CLI, does every read and every write:
+ *
+ *  - reads: only the configured source files, each resolved on the real disk inside the workspace
+ *    (`..`, absolute paths and symlinks out are refused), and never under `applications/`, where
+ *    generated material — this instance's or another's — lives;
+ *  - writes: only new files in a fresh `<workspace>/applications/<leadId>/<runId>/`, created
+ *    exclusively (`wx`), so a master source is never rewritten and two runs never share a folder;
+ *  - the trace carries handles (role, owner-visible path, sha256, byte count), never content.
+ *
+ * A missing source, an unusable workspace, a CLI that is not signed in, an API key in the env, a
+ * malformed lead or a draft whose claims do not check out ends the run `needs_human` — a pause
+ * the owner resolves — never a plausible guess written to disk.
+ *
+ * Runs live in memory, like local browser runs: a restart loses them and `status` answers 404,
+ * which PAGS reads as "the runner lost this run". Generated folders carry a manifest with their
+ * retention date; a later run on the same workspace removes those past it.
+ */
+import { spawn as nodeSpawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve, sep } from "node:path";
+import { RunnerInputError } from "../errors.js";
+import { redactText, secretEnvValues } from "../local-browser/contract.js";
+import { resolveWorkspacePath } from "../local-browser/runtime.js";
+import { LOCAL_ARTIFACT_AUTH_MODES, LOCAL_ARTIFACT_CAPS, LOCAL_ARTIFACT_ENGINES, LOCAL_ARTIFACT_SOURCE_ROLES, LOCAL_ARTIFACT_TASK_TYPE, PATH_SEGMENT, REQUIRED_SOURCE_ROLES, isHomeRelative, isWorkspaceRelative, parseLocalArtifactLead, } from "./contract.js";
+import { buildArtifactEngineSpec, checkDraft, finalText, missingLogin, observedArtifactAuth, parseDraft, tailorPrompt } from "./engine.js";
+/** The manifest in every generated folder — what retention reads, and proof the folder is ours. */
+export const ARTIFACT_MANIFEST = ".pags-artifact.json";
+const MAX_EVENTS = 200;
+const OUTPUT_LINES = 400;
+const SAFE_ID = /^[A-Za-z0-9_.:-]{1,300}$/;
+const DAY_MS = 86_400_000;
+const intIn = (v, min, max) => (typeof v === "number" && Number.isInteger(v) && v >= min && v <= max ? v : null);
+/** The envelope, validated at the runner's boundary. A bad LEAD is not thrown: it pauses the run. */
+export function parseArtifactEnvelope(raw) {
+    const o = (raw && typeof raw === "object" ? raw : {});
+    const bad = (what) => new RunnerInputError(`Invalid local artifact task: ${what}`);
+    if (o.type !== LOCAL_ARTIFACT_TASK_TYPE)
+        throw bad(`type must be ${LOCAL_ARTIFACT_TASK_TYPE}`);
+    if (typeof o.runId !== "string" || !PATH_SEGMENT.test(o.runId))
+        throw bad("runId is required");
+    for (const k of ["requestId", "instanceId"])
+        if (typeof o[k] !== "string" || !SAFE_ID.test(o[k]))
+            throw bad(`${k} is required`);
+    if (!LOCAL_ARTIFACT_ENGINES.includes(o.engine))
+        throw bad("engine must be claude or codex");
+    if (!LOCAL_ARTIFACT_AUTH_MODES.includes(o.authMode))
+        throw bad("authMode must be machine or subscription — a provider API key is never used");
+    if (typeof o.workspace !== "string" || !isHomeRelative(o.workspace))
+        throw bad('workspace must be a folder written "~/…"');
+    if (!Array.isArray(o.sources) || o.sources.length > LOCAL_ARTIFACT_CAPS.sources)
+        throw bad("sources must be a list");
+    const sources = [];
+    for (const s of o.sources) {
+        const r = (s && typeof s === "object" ? s : {});
+        if (!LOCAL_ARTIFACT_SOURCE_ROLES.includes(r.role) || typeof r.path !== "string" || !isWorkspaceRelative(r.path))
+            throw bad("each source needs a role and a path inside the workspace");
+        if (r.path.split("/")[0] === "applications")
+            throw bad("a source may not be inside applications/, where generated material lives");
+        if (sources.some((x) => x.role === r.role))
+            throw bad(`source ${String(r.role)} is listed twice`);
+        sources.push({ role: r.role, path: r.path });
+    }
+    const p = (o.policy && typeof o.policy === "object" ? o.policy : {});
+    const retainDays = intIn(p.retainDays, 0, 3650);
+    const maxMinutes = intIn(p.maxMinutes, 1, 60);
+    const maxConcurrent = intIn(p.maxConcurrent, 1, 3);
+    if (retainDays === null || maxMinutes === null || maxConcurrent === null)
+        throw bad("policy limits are out of range");
+    const lead = parseLocalArtifactLead(o.lead);
+    return {
+        type: LOCAL_ARTIFACT_TASK_TYPE,
+        runId: o.runId,
+        requestId: o.requestId,
+        instanceId: o.instanceId,
+        engine: o.engine,
+        authMode: o.authMode,
+        workspace: o.workspace,
+        sources,
+        policy: { retainDays, maxMinutes, maxConcurrent },
+        ...("lead" in lead ? { lead: lead.lead } : { lead: null, leadError: lead.error }),
+    };
+}
+const sha256 = (data) => createHash("sha256").update(data).digest("hex");
+/** A source file resolved on the real disk, strictly inside the workspace. */
+export function resolveSource(workspace, rel) {
+    const real = realpathSync(resolve(workspace, rel));
+    if (!real.startsWith(workspace + sep))
+        throw new Error("outside the workspace");
+    if (real.slice(workspace.length + 1).split(sep)[0] === "applications")
+        throw new Error("inside applications/");
+    if (!statSync(real).isFile())
+        throw new Error("not a file");
+    return real;
+}
+class Pause extends Error {
+    reason;
+    questions;
+    constructor(reason, questions) {
+        super(reason);
+        this.reason = reason;
+        this.questions = questions;
+    }
+}
+export class LocalArtifactRuntime {
+    deps;
+    runs = new Map();
+    root;
+    now;
+    spawn;
+    retentionMs;
+    constructor(deps) {
+        this.deps = deps;
+        this.root = join(deps.dataDir, "local-artifact");
+        this.now = deps.now ?? Date.now;
+        this.spawn = deps.spawn ?? nodeSpawn;
+        this.retentionMs = deps.retentionMs ?? DAY_MS;
+    }
+    /** Start a run. A requestId already held for the instance returns that run instead. */
+    start(raw) {
+        const envelope = parseArtifactEnvelope(raw);
+        this.sweep();
+        const same = [...this.runs.values()].find((r) => r.envelope.instanceId === envelope.instanceId && r.envelope.requestId === envelope.requestId);
+        if (same)
+            return { runId: same.envelope.runId, taskId: same.envelope.runId, status: same.state, existing: true };
+        if (this.runs.has(envelope.runId))
+            throw new RunnerInputError(`Run ${envelope.runId} already exists with another requestId`, 409);
+        const active = [...this.runs.values()].filter((r) => r.envelope.instanceId === envelope.instanceId && r.state !== "ended").length;
+        if (active >= envelope.policy.maxConcurrent)
+            throw new RunnerInputError(`This machine is already tailoring ${active} application(s) for this agent (limit ${envelope.policy.maxConcurrent}).`, 409);
+        const scratch = join(this.root, envelope.instanceId.replace(/[^A-Za-z0-9_-]/g, "_"), envelope.runId);
+        mkdirSync(scratch, { recursive: true });
+        const run = { envelope, scratch, state: "running", events: [], seq: 0, output: [], secrets: secretEnvValues(process.env), engineAuth: "unknown", cancelled: false, timedOut: false };
+        this.runs.set(envelope.runId, run);
+        void this.launch(run).catch((err) => {
+            if (err instanceof Pause)
+                this.pauseEnd(run, err.reason, err.questions);
+            else
+                this.end(run, { outcome: "failed", error: err instanceof Error ? err.message : String(err) });
+        });
+        return { runId: envelope.runId, taskId: envelope.runId, status: run.state, existing: false };
+    }
+    async launch(run) {
+        const e = run.envelope;
+        if (!e.lead)
+            throw new Pause("malformed_lead", [`The approved lead could not be read (${e.leadError ?? "malformed"}). Re-approve it from the Scout.`]);
+        const lead = e.lead;
+        let workspace;
+        try {
+            workspace = resolveWorkspacePath(e.workspace, this.deps.homeDir ?? homedir());
+        }
+        catch (err) {
+            throw new Pause("workspace_unavailable", [`The workspace ${e.workspace} cannot be used: ${err instanceof Error ? err.message : String(err)}`]);
+        }
+        this.sweepArtifacts(run, workspace);
+        // Sources: read by the runtime, hashed, handed to the CLI in its prompt. Content never leaves this function except into the prompt.
+        const texts = [];
+        const hashes = [];
+        const missing = [];
+        for (const s of e.sources) {
+            const shown = `${e.workspace}/${s.path}`;
+            try {
+                const file = resolveSource(workspace, s.path);
+                const buf = readFileSync(file);
+                if (buf.length > LOCAL_ARTIFACT_CAPS.sourceBytes)
+                    throw new Error(`larger than ${LOCAL_ARTIFACT_CAPS.sourceBytes / 1024} KB`);
+                if (!buf.length)
+                    throw new Error("empty");
+                texts.push({ role: s.role, text: buf.toString("utf8") });
+                const hash = { role: s.role, path: shown, sha256: sha256(buf), bytes: buf.length };
+                hashes.push(hash);
+                this.emit(run, { type: "source.read", detail: hash });
+            }
+            catch (err) {
+                this.emit(run, { type: "source.missing", detail: { role: s.role, path: shown } });
+                missing.push(`Your ${s.role} at ${shown} could not be read (${err instanceof Error && !/ENOENT/.test(err.message) ? err.message : "not found"}). Add it, or choose another file in the Application Tailor settings.`);
+            }
+        }
+        for (const role of REQUIRED_SOURCE_ROLES) {
+            if (!e.sources.some((s) => s.role === role))
+                missing.push(`No ${role} source is configured. Choose one in the Application Tailor settings.`);
+        }
+        if (missing.length)
+            throw new Pause("missing_source", missing);
+        const outRel = `applications/${lead.leadId}/${e.runId}`;
+        const outDir = join(workspace, "applications", lead.leadId, e.runId);
+        try {
+            mkdirSync(join(workspace, "applications", lead.leadId), { recursive: true });
+            mkdirSync(outDir); // exclusive: a run never writes into a folder it did not create
+            if (!realpathSync(outDir).startsWith(workspace + sep))
+                throw new Error("the output folder resolves outside the workspace");
+        }
+        catch (err) {
+            throw new Pause("workspace_unavailable", [`Cannot create ${e.workspace}/${outRel}: ${err instanceof Error ? err.message : String(err)}`]);
+        }
+        const spec = buildArtifactEngineSpec({ engine: e.engine, authMode: e.authMode, prompt: tailorPrompt(lead, texts) });
+        run.secrets = secretEnvValues({ ...process.env, ...spec.env });
+        run.engineAuth = observedArtifactAuth(e.engine, spec.env);
+        this.emit(run, { type: "engine.auth_checked", detail: { engine: e.engine, authMode: e.authMode, engineAuth: run.engineAuth } });
+        if (run.engineAuth === "api-key") {
+            rmdirSync(outDir);
+            throw new Pause("api_key_refused", ["A provider API key would reach the CLI. The Application Tailor runs on your machine's sign-in only — remove the key from the runner's environment."]);
+        }
+        const child = this.spawn(spec.command, spec.args, { cwd: run.scratch, env: spec.env, stdio: ["ignore", "pipe", "pipe"] });
+        run.child = child;
+        this.emit(run, { type: "engine.started", detail: { engine: e.engine } });
+        let buf = "";
+        const keep = (chunk) => {
+            buf += chunk.toString();
+            const lines = buf.split("\n");
+            buf = lines.pop() ?? "";
+            for (const line of lines)
+                if (line.trim())
+                    run.output.push(line.slice(0, 200_000));
+            if (run.output.length > OUTPUT_LINES)
+                run.output.splice(0, run.output.length - OUTPUT_LINES);
+        };
+        child.stdout?.on("data", keep);
+        child.stderr?.on("data", keep);
+        child.on("error", (err) => {
+            this.removeIfEmpty(outDir);
+            this.end(run, { outcome: "failed", error: err.code === "ENOENT" ? `The ${e.engine === "claude" ? "Claude Code" : "Codex"} CLI is not installed on this machine (\`${spec.command}\` was not found).` : err.message });
+        });
+        child.on("close", (code) => {
+            if (buf.trim())
+                run.output.push(buf);
+            this.emit(run, { type: "engine.ended", detail: { exitCode: code ?? -1 } });
+            try {
+                this.finish(run, code ?? -1, { workspace, outDir, outRel, lead, hashes, texts });
+            }
+            catch (err) {
+                this.removeIfEmpty(outDir);
+                this.end(run, { outcome: "failed", error: err instanceof Error ? err.message : String(err) });
+            }
+        });
+        run.timer = setTimeout(() => {
+            run.timedOut = true;
+            this.kill(run);
+        }, e.policy.maxMinutes * 60_000);
+        run.timer.unref?.();
+    }
+    /** The CLI exited: check its draft against the sources, and only then write the artifacts. */
+    finish(run, code, ctx) {
+        if (run.state === "ended")
+            return;
+        const e = run.envelope;
+        const output = run.output.join("\n");
+        if (run.cancelled || run.timedOut) {
+            this.removeIfEmpty(ctx.outDir);
+            this.end(run, { outcome: "failed", error: run.cancelled ? "Cancelled by the owner" : `Stopped at the ${e.policy.maxMinutes}-minute limit.` });
+            return;
+        }
+        const text = finalText(e.engine, run.output);
+        if (!text && missingLogin(e.engine, output)) {
+            this.removeIfEmpty(ctx.outDir);
+            run.engineAuth = "missing_login";
+            this.pauseEnd(run, "engine_not_signed_in", [e.engine === "claude" ? "Sign in to Claude Code on this machine (run `claude`, then /login), then retry." : "Sign in to Codex on this machine (`codex login`), then retry."]);
+            return;
+        }
+        if (code !== 0 && !text) {
+            this.removeIfEmpty(ctx.outDir);
+            this.end(run, { outcome: "failed", error: `The ${e.engine} CLI exited with code ${code}: ${run.output.slice(-5).join("\n").slice(-800)}` });
+            return;
+        }
+        const check = checkDraft(parseDraft(text), ctx.texts);
+        this.emit(run, { type: "claims.checked", detail: { total: check.claims, unmatched: check.ok ? 0 : check.unmatched } });
+        if (!check.ok) {
+            this.removeIfEmpty(ctx.outDir);
+            this.pauseEnd(run, check.reason, check.questions);
+            return;
+        }
+        const at = new Date(this.now()).toISOString();
+        const artifacts = [];
+        for (const [kind, name, body] of [
+            ["resume", "resume.md", check.resume],
+            ["cover_letter", "cover-letter.md", check.coverLetter],
+        ]) {
+            const content = `${body}\n`;
+            writeFileSync(join(ctx.outDir, name), content, { flag: "wx", mode: 0o600 });
+            const file = { kind, path: `${e.workspace}/${ctx.outRel}/${name}`, sha256: sha256(content), bytes: Buffer.byteLength(content) };
+            artifacts.push(file);
+            this.emit(run, { type: "artifact.written", detail: { ...file } });
+        }
+        const profileVersion = sha256(ctx.hashes.map((h) => `${h.role}:${h.sha256}`).sort().join("\n")).slice(0, 16);
+        const retainUntil = e.policy.retainDays > 0 ? this.now() + e.policy.retainDays * DAY_MS : null;
+        writeFileSync(join(ctx.outDir, ARTIFACT_MANIFEST), JSON.stringify({ runId: e.runId, instanceId: e.instanceId, leadId: ctx.lead.leadId, eventId: ctx.lead.eventId, generatedAt: at, retainUntil, profileVersion, artifacts, sources: ctx.hashes }, null, 2), { flag: "wx", mode: 0o600 });
+        this.end(run, { outcome: "completed", artifacts, sourceHashes: ctx.hashes, profileVersion, generatedAt: at });
+    }
+    /** Retention: remove generated folders whose manifest says they are past their date. Only ours — a folder without a manifest is the owner's. */
+    sweepArtifacts(run, workspace) {
+        const apps = join(workspace, "applications");
+        if (!existsSync(apps))
+            return;
+        let removed = 0;
+        for (const lead of readdirSync(apps)) {
+            const leadDir = join(apps, lead);
+            if (!statSync(leadDir).isDirectory())
+                continue;
+            for (const runId of readdirSync(leadDir)) {
+                const manifest = join(leadDir, runId, ARTIFACT_MANIFEST);
+                if (!existsSync(manifest))
+                    continue;
+                try {
+                    const m = JSON.parse(readFileSync(manifest, "utf8"));
+                    if (typeof m.retainUntil === "number" && m.retainUntil < this.now()) {
+                        rmSync(join(leadDir, runId), { recursive: true, force: true });
+                        removed++;
+                    }
+                }
+                catch {
+                    // An unreadable manifest is left alone: deleting on a guess is the one thing retention must not do.
+                }
+            }
+            this.removeIfEmpty(leadDir);
+        }
+        if (removed)
+            this.emit(run, { type: "retention.swept", detail: { removed } });
+    }
+    removeIfEmpty(dir) {
+        try {
+            if (existsSync(dir) && readdirSync(dir).length === 0)
+                rmdirSync(dir);
+        }
+        catch {
+            // best-effort
+        }
+    }
+    emit(run, ev) {
+        if (run.events.length >= MAX_EVENTS)
+            return;
+        run.events.push({ ...ev, at: new Date(this.now()).toISOString(), seq: ++run.seq });
+    }
+    pauseEnd(run, reason, questions) {
+        this.emit(run, { type: "run.needs_human", detail: { reason, count: questions.length } });
+        this.end(run, { outcome: "needs_human", blockReason: reason, questions });
+    }
+    end(run, r) {
+        if (run.state === "ended")
+            return;
+        if (run.timer)
+            clearTimeout(run.timer);
+        run.state = "ended";
+        run.endedAt = this.now();
+        run.result = {
+            runId: run.envelope.runId,
+            outcome: r.outcome,
+            artifacts: r.artifacts ?? [],
+            sourceHashes: r.sourceHashes ?? [],
+            profileVersion: r.profileVersion ?? null,
+            engineAuth: run.engineAuth,
+            traceId: run.envelope.runId,
+            ...(r.generatedAt ? { generatedAt: r.generatedAt } : {}),
+            ...(r.outcome === "needs_human" ? { blockReason: r.blockReason, questions: (r.questions ?? []).map((q) => redactText(q, run.secrets)) } : {}),
+            // CLI output becomes this text, and a CLI prints whatever it was given: redacted before it is kept.
+            ...(r.outcome === "failed" ? { error: redactText((r.error ?? "The run failed without a reason.").slice(0, 1000), run.secrets) } : {}),
+        };
+        if (run.child && run.child.exitCode === null)
+            this.kill(run);
+    }
+    kill(run) {
+        const child = run.child;
+        if (!child || child.exitCode !== null)
+            return;
+        child.kill("SIGTERM");
+        setTimeout(() => {
+            if (child.exitCode === null)
+                child.kill("SIGKILL");
+        }, 5_000).unref?.();
+    }
+    get(runId) {
+        const run = this.runs.get(runId);
+        if (!run)
+            throw new RunnerInputError(`No local artifact run ${runId} on this runner (it may have restarted)`, 404);
+        return run;
+    }
+    status(raw) {
+        const o = (raw && typeof raw === "object" ? raw : {});
+        const run = this.get(String(o.runId ?? ""));
+        const after = typeof o.afterSeq === "number" && o.afterSeq > 0 ? o.afterSeq : 0;
+        return { runId: run.envelope.runId, state: run.state, events: run.events.filter((e) => e.seq > after), lastSeq: run.seq, ...(run.result ? { result: run.result } : {}) };
+    }
+    cancel(raw) {
+        const runId = String(raw?.runId ?? "");
+        const run = this.get(runId);
+        if (run.state !== "ended") {
+            run.cancelled = true;
+            if (run.child && run.child.exitCode === null)
+                this.kill(run);
+            else
+                this.end(run, { outcome: "failed", error: "Cancelled by the owner" });
+        }
+        return { runId, state: run.state };
+    }
+    /** Drop ended runs past retention with their scratch folders. Generated artifacts are swept by their own manifest, not here. */
+    sweep() {
+        const cutoff = this.now() - this.retentionMs;
+        for (const [id, run] of this.runs) {
+            if (run.state === "ended" && (run.endedAt ?? 0) < cutoff) {
+                rmSync(run.scratch, { recursive: true, force: true });
+                this.runs.delete(id);
+            }
+        }
+    }
+    closeAll() {
+        for (const run of this.runs.values()) {
+            if (run.state !== "ended") {
+                run.cancelled = true;
+                this.end(run, { outcome: "failed", error: "The runner shut down during the run" });
+            }
+        }
+    }
+}

package/dist/browser-runner/local-browser/engine.js

@@ -101,7 +101,7 @@ export function buildEngineSpec(input) {
             "-c",
             `${key}.default_tools_approval_mode="approve"`,
             "-c",
-            `${key}.enabled_tools=[${BRIDGE_TOOL_NAMES.map(toml).join(", ")}]`,
+            `${key}.enabled_tools=[${(input.toolNames ?? BRIDGE_TOOL_NAMES).map(toml).join(", ")}]`,
             // Two spellings across Codex versions; an unknown key is ignored, so both are set.
             "-c",
             'web_search="disabled"',

package/dist/browser-runner/runner.js

@@ -14,6 +14,10 @@ import { RunnerStore } from "./store.js";
 import { CodingRuntime } from "./coding/runtime.js";
 import { LocalBrowserRuntime } from "./local-browser/runtime.js";
 import { LOCAL_BROWSER_TASK_TYPE } from "./local-browser/contract.js";
+import { LocalArtifactRuntime } from "./local-artifact/runtime.js";
+import { LOCAL_ARTIFACT_TASK_TYPE } from "./local-artifact/contract.js";
+import { LocalApplyRuntime } from "./local-apply/runtime.js";
+import { LOCAL_APPLY_TASK_TYPE } from "./local-apply/contract.js";
 import { WORKFLOW_DRIVEN_TASKS } from "./task-types.js";
 /** True for a plain object. */
 function isRecord(value) {
@@ -77,6 +81,10 @@ export class LocalRunner {
     coding;
     /** Local CLI browser research (#944): a signed-in Codex / Claude Code CLI researching through the policy bridge. */
     localBrowser;
+    /** Local artifact generation (#956): the Application Tailor's résumé + cover letter, from the owner's own files. */
+    localArtifact;
+    /** Local application execution (#957): a signed-in CLI filling one application through the apply bridge. */
+    localApply;
     /** This runner's own local URL, once the server listens — the bridge forwarder calls back to it. */
     selfUrl = null;
     /** Live human-takeover sessions, keyed by task id (the page is kept alive). */
@@ -86,19 +94,18 @@ export class LocalRunner {
         mkdirSync(config.dataDir, { recursive: true });
         this.store = new RunnerStore(config.dataDir);
         this.coding = new CodingRuntime(join(config.dataDir, "repos"));
-        this.localBrowser = new LocalBrowserRuntime({
-            dataDir: config.dataDir,
-            selfUrl: () => this.selfUrl,
-            // `default` is the runner's own signed-in browser, shared and never closed by a run;
-            // `isolated` is a fresh profile inside the run's folder, removed with it.
-            browserFor: async (profile, runDir) => {
-                if (profile === "default")
-                    return { tools: await this.getMcp(), stop: async () => undefined };
-                const mcp = new McpRuntime();
-                await mcp.start({ userDataDir: join(runDir, "profile"), headless: config.headless });
-                return { tools: mcp, stop: () => mcp.stop() };
-            },
-        });
+        // `default` is the runner's own signed-in browser, shared and never closed by a run;
+        // `isolated` is a fresh profile inside the run's folder, removed with it.
+        const browserFor = async (profile, runDir) => {
+            if (profile === "default")
+                return { tools: await this.getMcp(), stop: async () => undefined };
+            const mcp = new McpRuntime();
+            await mcp.start({ userDataDir: join(runDir, "profile"), headless: config.headless });
+            return { tools: mcp, stop: () => mcp.stop() };
+        };
+        this.localBrowser = new LocalBrowserRuntime({ dataDir: config.dataDir, selfUrl: () => this.selfUrl, browserFor });
+        this.localArtifact = new LocalArtifactRuntime({ dataDir: config.dataDir });
+        this.localApply = new LocalApplyRuntime({ dataDir: config.dataDir, selfUrl: () => this.selfUrl, browserFor });
         // Tasks paused/running on a previous process are orphaned now — their
         // pages and takeover sessions are gone. Fail them so the board is clean.
         const expired = this.store.expireInFlightTasks();
@@ -113,7 +120,7 @@ export class LocalRunner {
             runtimePlane: "pags",
             runnerRole: "tool-executor",
             capabilities: [...CAPABILITIES, ...CodingRuntime.capabilities()],
-            taskTypes: ["echo", "browser.open", "job.apply_agent", "site_builder_runtime", LOCAL_BROWSER_TASK_TYPE, ...CodingRuntime.taskTypes()],
+            taskTypes: ["echo", "browser.open", "job.apply_agent", "site_builder_runtime", LOCAL_BROWSER_TASK_TYPE, LOCAL_ARTIFACT_TASK_TYPE, LOCAL_APPLY_TASK_TYPE, ...CodingRuntime.taskTypes()],
             approvalRequiredFor: [...APPROVAL_REQUIRED_TASKS],
         };
     }
@@ -250,6 +257,8 @@ export class LocalRunner {
      */
     async close() {
         this.localBrowser.closeAll();
+        this.localArtifact.closeAll();
+        this.localApply.closeAll();
         try {
             this.coding.closeAll();
         }

package/dist/browser-runner/server.js

@@ -12,7 +12,11 @@ export function createRunnerServer(runner) {
             if (!req.headers.origin && req.method === "POST" && (req.url || "").split("?")[0] === "/local-browser/bridge") {
                 const body = await readJson(req);
                 const token = String(req.headers["x-pags-bridge-token"] || "");
-                if (!runner.localBrowser.authorizeBridge(String(body.runId ?? ""), token))
+                const runId = String(body.runId ?? "");
+                // The same forwarder serves application runs (#957); each runtime knows only its own tokens.
+                if (runner.localApply.authorizeBridge(runId, token))
+                    return json(res, 200, await runner.localApply.bridge(body));
+                if (!runner.localBrowser.authorizeBridge(runId, token))
                     return json(res, 401, { error: "Unauthorized" });
                 return json(res, 200, await runner.localBrowser.bridge(body));
             }
@@ -177,6 +181,29 @@ async function route(runner, req, res) {
     if (req.method === "POST" && path === "/local-browser/cancel") {
         return json(res, 200, runner.localBrowser.cancel(await readJson(req)));
     }
+    // Local artifact generation (#956) — the same PULL shape: run, status, cancel.
+    if (req.method === "POST" && path === "/local-artifact/run") {
+        return json(res, 202, runner.localArtifact.start(await readJson(req)));
+    }
+    if (req.method === "POST" && path === "/local-artifact/status") {
+        return json(res, 200, runner.localArtifact.status(await readJson(req)));
+    }
+    if (req.method === "POST" && path === "/local-artifact/cancel") {
+        return json(res, 200, runner.localArtifact.cancel(await readJson(req)));
+    }
+    // Local application execution (#957) — run, status, resume, cancel; PULL like research.
+    if (req.method === "POST" && path === "/local-apply/run") {
+        return json(res, 202, runner.localApply.start(await readJson(req)));
+    }
+    if (req.method === "POST" && path === "/local-apply/status") {
+        return json(res, 200, runner.localApply.status(await readJson(req)));
+    }
+    if (req.method === "POST" && path === "/local-apply/resume") {
+        return json(res, 200, runner.localApply.resume(await readJson(req)));
+    }
+    if (req.method === "POST" && path === "/local-apply/cancel") {
+        return json(res, 200, runner.localApply.cancel(await readJson(req)));
+    }
     if (req.method === "POST" && path === "/coding/start") {
         const b = await readJson(req);
         return json(res, 200, runner.coding.start(b));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.77",
+  "version": "0.4.79",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",