@timqi/pier 0.0.1

package/dist/tasks/callbacks.js

@@ -0,0 +1,140 @@
+import { Router } from "../core/router.js";
+import { logger } from "../log.js";
+import { TaskStore } from "./store.js";
+const log = logger("tasks");
+export function runResultText(run) {
+    let result = run.error ?? "No result";
+    if (run.result?.type === "agent")
+        result = run.result.text;
+    if (run.result?.type === "bash")
+        result = run.result.stdout || run.result.stderr || `exit ${String(run.result.exitCode)}`;
+    if (run.result?.type === "task")
+        result = JSON.stringify(run.result.result);
+    if (run.result?.type === "watch")
+        result = "Watch condition did not match";
+    if (result.length > 8000)
+        result = `${result.slice(0, 8000)}\n[truncated; open run ${run.id}]`;
+    return result;
+}
+export class TaskCallbacks {
+    store;
+    router;
+    changed;
+    delivering = new Set();
+    constructor(store, router, changed) {
+        this.store = store;
+        this.router = router;
+        this.changed = changed;
+    }
+    target(callback, origin) {
+        if (callback.type === "session")
+            return callback.sessionId;
+        if (callback.type === "origin")
+            return origin;
+        return null;
+    }
+    recover(now = Date.now()) {
+        for (const run of this.store.listPendingCallbacks(now))
+            void this.deliver(run);
+    }
+    /** Delivers the candidate and, in the same system input, every other
+     * deliverable callback aimed at the same session: one model turn drains the
+     * backlog instead of one turn per run. */
+    async deliver(candidate) {
+        if (this.delivering.has(candidate.id))
+            return;
+        const first = this.store.getRun(candidate.id);
+        if (!first?.callbackSessionId || (first.callbackState !== "pending" && first.callbackState !== "failed"))
+            return;
+        const sessionId = first.callbackSessionId;
+        // Ignore retry due-times when sweeping the batch: once one callback is
+        // deliverable, everything pending for the session rides along.
+        const batch = this.store.listPendingCallbacks(Number.MAX_SAFE_INTEGER).filter((run) => run.callbackSessionId === sessionId && !this.delivering.has(run.id));
+        if (!batch.some((run) => run.id === first.id))
+            return;
+        for (const run of batch)
+            this.delivering.add(run.id);
+        try {
+            const session = await this.router.ensure({ channelId: "task", conversationId: sessionId });
+            // Crash-window idempotency: any run id already present in a persisted
+            // callback input (single or batched) must not be sent again.
+            const seen = new Set();
+            for (const turn of await session.history()) {
+                if (turn.role !== "system" || turn.origin?.kind !== "task-callback")
+                    continue;
+                for (const id of turn.origin.runIds ?? [turn.origin.runId])
+                    seen.add(id);
+            }
+            const fresh = batch.filter((run) => !seen.has(run.id));
+            // Waiting for a busy target is not a delivery attempt: counting it would
+            // inflate `callbackAttempts` once per second and skip the real failure
+            // backoff straight to its ceiling.
+            if (fresh.length > 0 && session.state === "streaming") {
+                for (const run of batch) {
+                    run.callbackNextAttemptAt = Date.now() + 1000;
+                    this.store.saveRun(run);
+                }
+                return;
+            }
+            for (const run of batch) {
+                run.callbackAttempts += 1;
+                run.callbackState = "pending";
+                run.callbackError = null;
+                this.store.saveRun(run);
+            }
+            // `systemInput` resolves when the turn it triggers settles, not when Pi
+            // accepts the input — so mark delivered first and let a rejection below
+            // flip it to failed. Otherwise a recipient turn that runs for minutes
+            // leaves the run "pending" and a restart in that window re-delivers.
+            const sent = fresh.length > 0
+                ? session.systemInput(this.text(fresh), {
+                    kind: "task-callback",
+                    taskId: fresh[0].taskId,
+                    runId: fresh[0].id,
+                    sourceSessionId: fresh[0].targetSessionId,
+                    runIds: fresh.map((run) => run.id),
+                }, "followUp")
+                : Promise.resolve();
+            for (const run of batch) {
+                run.callbackState = "delivered";
+                run.callbackNextAttemptAt = null;
+                this.store.saveRun(run);
+                this.changed(run);
+            }
+            if (fresh.length > 0) {
+                log.debug(`callback for ${fresh.map((run) => run.id).join(", ")} → session ${sessionId}`);
+            }
+            await sent;
+        }
+        catch (error) {
+            // The delegating agent is waiting for an answer that is now late: the
+            // retry is silent, so this line is the only sign it is being retried.
+            log.warn(`callback to session ${sessionId} failed, will retry`, error);
+            for (const stale of batch) {
+                const run = this.store.getRun(stale.id);
+                if (!run)
+                    continue;
+                run.callbackState = "failed";
+                run.callbackError = String(error);
+                run.callbackNextAttemptAt = Date.now() + Math.min(60_000, 1000 * 2 ** Math.min(run.callbackAttempts, 6));
+                this.store.saveRun(run);
+                this.changed(run);
+            }
+        }
+        finally {
+            for (const run of batch)
+                this.delivering.delete(run.id);
+        }
+    }
+    text(runs) {
+        const sections = runs.map((run) => [
+            `Task "${run.context.definition.name}" finished with state: ${run.state}`,
+            `Run: ${run.id}`,
+            "",
+            runResultText(run),
+        ].join("\n"));
+        if (sections.length === 1)
+            return sections[0];
+        return [`${String(sections.length)} task callbacks`, "", sections.join("\n\n---\n\n")].join("\n");
+    }
+}

package/dist/tasks/command.js

@@ -0,0 +1,74 @@
+import { spawn } from "node:child_process";
+const OUTPUT_LIMIT = 1024 * 1024;
+class CappedOutput {
+    chunks = [];
+    bytes = 0;
+    truncated = false;
+    add(chunk) {
+        if (this.bytes >= OUTPUT_LIMIT) {
+            this.truncated = true;
+            return;
+        }
+        const kept = chunk.subarray(0, OUTPUT_LIMIT - this.bytes);
+        this.chunks.push(kept);
+        this.bytes += kept.length;
+        if (kept.length < chunk.length)
+            this.truncated = true;
+    }
+    text() {
+        return Buffer.concat(this.chunks).toString("utf8");
+    }
+}
+export function runBash(script, cwd, input, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted)
+            return reject(new Error("cancelled"));
+        const encodedInput = JSON.stringify(input ?? null);
+        const child = spawn("/bin/bash", ["-lc", script], {
+            cwd,
+            detached: process.platform !== "win32",
+            env: { ...process.env, PIER_TASK_INPUT: encodedInput },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const stdout = new CappedOutput();
+        const stderr = new CappedOutput();
+        let settled = false;
+        const kill = () => {
+            if (!child.pid)
+                return;
+            try {
+                if (process.platform === "win32")
+                    child.kill("SIGTERM");
+                else
+                    process.kill(-child.pid, "SIGTERM");
+            }
+            catch {
+                // The process may have exited between the state check and kill.
+            }
+        };
+        signal.addEventListener("abort", kill, { once: true });
+        child.stdout.on("data", (chunk) => stdout.add(chunk));
+        child.stderr.on("data", (chunk) => stderr.add(chunk));
+        child.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener("abort", kill);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener("abort", kill);
+            resolve({
+                exitCode: code,
+                stdout: stdout.text(),
+                stderr: stderr.text(),
+                stdoutTruncated: stdout.truncated,
+                stderrTruncated: stderr.truncated,
+            });
+        });
+        child.stdin.end(encodedInput);
+    });
+}

package/dist/tasks/definitions.js

@@ -0,0 +1,316 @@
+import { randomUUID } from "node:crypto";
+import { stat } from "node:fs/promises";
+import { Cron } from "croner";
+import { isThinkingLevel } from "../core/types.js";
+import { EventHub } from "../core/hub.js";
+import { Router } from "../core/router.js";
+import { TaskStore } from "./store.js";
+const DEFAULT_TIMEOUT = 900;
+const MIN_WATCH_SECONDS = 5;
+export const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
+export const requiredString = (value, field) => {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`${field} required`);
+    return value.trim();
+};
+function parseTrigger(raw) {
+    const value = record(raw);
+    if (!value)
+        throw new Error("trigger required");
+    if (value.type === "manual")
+        return { type: "manual" };
+    if (value.type === "cron") {
+        const expression = requiredString(value.expression, "cron expression");
+        if (expression.split(/\s+/).length !== 5)
+            throw new Error("cron expression must have five fields");
+        const timezone = requiredString(value.timezone, "cron timezone");
+        new Intl.DateTimeFormat("en", { timeZone: timezone }).format();
+        new Cron(expression, { timezone });
+        return { type: "cron", expression, timezone };
+    }
+    if (value.type === "watch") {
+        const intervalSeconds = Number(value.intervalSeconds);
+        if (!Number.isInteger(intervalSeconds) || intervalSeconds < MIN_WATCH_SECONDS) {
+            throw new Error(`watch interval must be at least ${MIN_WATCH_SECONDS} seconds`);
+        }
+        return {
+            type: "watch",
+            script: requiredString(value.script, "watch script"),
+            cwd: requiredString(value.cwd, "watch cwd"),
+            intervalSeconds,
+            mode: value.mode === "once" ? "once" : "repeat",
+        };
+    }
+    throw new Error("unknown trigger type");
+}
+export function nextRunAt(trigger, from) {
+    if (trigger.type === "manual")
+        return null;
+    if (trigger.type === "watch")
+        return from + trigger.intervalSeconds * 1000;
+    return new Cron(trigger.expression, { timezone: trigger.timezone }).nextRun(new Date(from))?.getTime() ?? null;
+}
+function parseLaunch(raw) {
+    if (raw === undefined)
+        return undefined;
+    const value = record(raw);
+    if (!value)
+        throw new Error("agent launch policy must be an object");
+    const launch = {};
+    if (value.model !== undefined) {
+        const model = record(value.model);
+        if (!model)
+            throw new Error("agent model must be an object");
+        launch.model = {
+            provider: requiredString(model.provider, "model provider"),
+            id: requiredString(model.id, "model id"),
+        };
+    }
+    if (value.thinking !== undefined) {
+        if (!isThinkingLevel(value.thinking)) {
+            throw new Error("invalid agent thinking level");
+        }
+        launch.thinking = value.thinking;
+    }
+    if (value.capabilities !== undefined) {
+        if (value.capabilities !== "read" && value.capabilities !== "write") {
+            throw new Error("agent capabilities must be read or write");
+        }
+        launch.capabilities = value.capabilities;
+    }
+    return Object.keys(launch).length ? launch : undefined;
+}
+export class TaskDefinitions {
+    store;
+    factory;
+    router;
+    hub;
+    constructor(store, factory, router, hub) {
+        this.store = store;
+        this.factory = factory;
+        this.router = router;
+        this.hub = hub;
+    }
+    list() { return this.store.listTasks(); }
+    get(id) {
+        const task = this.store.getTask(id);
+        if (!task)
+            throw new Error(`unknown task: ${id}`);
+        return task;
+    }
+    async create(raw, creator = "http", kind = "task") {
+        // The tool schema marks trigger optional, so a trigger-less new definition
+        // means manual. Update keeps requiring it: replacing a cron task with a
+        // draft that forgot its trigger must not silently unschedule it.
+        const value = record(raw);
+        const draft = await this.parseDraft(value && value.trigger === undefined ? { ...value, trigger: { type: "manual" } } : raw);
+        const now = Date.now();
+        const task = {
+            id: randomUUID(),
+            kind,
+            name: draft.name,
+            description: draft.description ?? "",
+            enabled: draft.enabled ?? true,
+            archived: false,
+            revision: 1,
+            trigger: draft.trigger,
+            action: draft.action,
+            callback: draft.callback ?? { type: "none" },
+            timeoutSeconds: draft.timeoutSeconds ?? DEFAULT_TIMEOUT,
+            nextRunAt: null,
+            creator,
+            createdBySessionId: creator.startsWith("session:") ? creator.slice("session:".length) : null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.assertNoCycle(task);
+        task.nextRunAt = task.enabled ? nextRunAt(task.trigger, now) : null;
+        this.store.saveTask(task);
+        this.changed();
+        return task;
+    }
+    async update(id, raw) {
+        const old = this.get(id);
+        if (old.archived)
+            throw new Error("archived tasks cannot be edited");
+        const draft = await this.parseDraft(raw);
+        const now = Date.now();
+        const task = {
+            ...old,
+            name: draft.name,
+            description: draft.description ?? "",
+            enabled: draft.enabled ?? old.enabled,
+            revision: old.revision + 1,
+            trigger: draft.trigger,
+            action: draft.action,
+            callback: draft.callback ?? old.callback,
+            timeoutSeconds: draft.timeoutSeconds ?? DEFAULT_TIMEOUT,
+            nextRunAt: null,
+            updatedAt: now,
+        };
+        this.assertNoCycle(task);
+        task.nextRunAt = task.enabled ? nextRunAt(task.trigger, now) : null;
+        this.store.saveTask(task);
+        this.changed();
+        return task;
+    }
+    setEnabled(id, enabled) {
+        const task = this.get(id);
+        if (task.archived && enabled)
+            throw new Error("archived tasks cannot be resumed");
+        task.enabled = enabled;
+        task.nextRunAt = enabled ? nextRunAt(task.trigger, Date.now()) : null;
+        task.updatedAt = Date.now();
+        this.store.saveTask(task);
+        this.changed();
+        return task;
+    }
+    archive(id) {
+        const task = this.get(id);
+        task.archived = true;
+        task.enabled = false;
+        task.nextRunAt = null;
+        task.updatedAt = Date.now();
+        this.store.saveTask(task);
+        this.changed();
+        return task;
+    }
+    resetNextRuns(now) {
+        for (const task of this.store.listTasks()) {
+            task.nextRunAt = task.enabled && !task.archived ? nextRunAt(task.trigger, now) : null;
+            this.store.saveTask(task);
+        }
+    }
+    claimDue(now) {
+        const due = [];
+        for (const task of this.store.listTasks()) {
+            if (!task.enabled || task.archived || task.nextRunAt === null || task.nextRunAt > now)
+                continue;
+            task.nextRunAt = nextRunAt(task.trigger, now);
+            this.store.saveTask(task);
+            due.push(task);
+        }
+        if (due.length)
+            this.changed();
+        return due;
+    }
+    async sessionExists(sessionId) {
+        return this.router.stateOf(sessionId) !== undefined ||
+            (await this.factory.list()).some((session) => session.id === sessionId);
+    }
+    async parseDraft(raw) {
+        const value = record(raw);
+        if (!value)
+            throw new Error("task definition required");
+        const timeoutSeconds = value.timeoutSeconds === undefined ? DEFAULT_TIMEOUT : Number(value.timeoutSeconds);
+        if (!Number.isInteger(timeoutSeconds) || timeoutSeconds < 1 || timeoutSeconds > 86_400) {
+            throw new Error("timeoutSeconds must be between 1 and 86400");
+        }
+        const trigger = parseTrigger(value.trigger);
+        if (trigger.type === "watch")
+            await this.assertDirectory(trigger.cwd);
+        const actionRaw = record(value.action);
+        // Self-documenting: tool callers (models) recover from this in one retry.
+        if (!actionRaw) {
+            throw new Error('action required, e.g. {"type":"agent","session":{"mode":"fresh","cwd":"/abs/path"},"prompt":"..."}');
+        }
+        let action;
+        if (actionRaw.type === "bash") {
+            const cwd = requiredString(actionRaw.cwd, "bash cwd");
+            await this.assertDirectory(cwd);
+            action = { type: "bash", script: requiredString(actionRaw.script, "bash script"), cwd };
+        }
+        else if (actionRaw.type === "task") {
+            const taskId = requiredString(actionRaw.taskId, "target task");
+            this.get(taskId);
+            action = { type: "task", taskId };
+        }
+        else if (actionRaw.type === "agent") {
+            action = await this.parseAgentAction(actionRaw, trigger);
+        }
+        else
+            throw new Error("unknown action type");
+        return {
+            name: requiredString(value.name, "name"),
+            description: typeof value.description === "string" ? value.description.trim() : "",
+            enabled: typeof value.enabled === "boolean" ? value.enabled : undefined,
+            trigger,
+            action,
+            callback: await this.parseCallback(value.callback),
+            timeoutSeconds,
+        };
+    }
+    async parseAgentAction(raw, trigger) {
+        const prompt = requiredString(raw.prompt, "agent prompt");
+        const launch = parseLaunch(raw.launch);
+        const input = record(raw.session);
+        let session;
+        if (input?.mode === "reuse") {
+            const sessionId = requiredString(input.sessionId, "agent session");
+            if (!(await this.sessionExists(sessionId)))
+                throw new Error(`unknown session: ${sessionId}`);
+            session = { mode: "reuse", sessionId };
+        }
+        else if (input?.mode === "fresh") {
+            const cwd = requiredString(input.cwd, "agent cwd");
+            await this.assertDirectory(cwd);
+            session = { mode: "fresh", cwd };
+        }
+        else if (input?.mode === "fork") {
+            if (trigger.type !== "manual")
+                throw new Error("fork Agent tasks must use a manual trigger");
+            const cwd = typeof input.cwd === "string" && input.cwd.trim() ? input.cwd.trim() : undefined;
+            if (cwd)
+                await this.assertDirectory(cwd);
+            session = { mode: "fork", ...(cwd ? { cwd } : {}) };
+        }
+        else if (typeof raw.sessionId === "string" && raw.sessionId.trim()) {
+            const sessionId = raw.sessionId.trim();
+            if (!(await this.sessionExists(sessionId)))
+                throw new Error(`unknown session: ${sessionId}`);
+            session = { mode: "reuse", sessionId };
+        }
+        else {
+            // Validation never mutates: a dedicated session is created explicitly
+            // (POST /api/sessions) and then referenced with mode:"reuse".
+            throw new Error('agent session policy required, e.g. {"mode":"fresh","cwd":"/abs/path"} or {"mode":"fork"} or {"mode":"reuse","sessionId":"..."}');
+        }
+        if (session.mode === "reuse" && launch)
+            throw new Error("launch policy only applies to fresh or fork sessions");
+        return { type: "agent", session, prompt, ...(launch ? { launch } : {}) };
+    }
+    async parseCallback(raw) {
+        if (raw === undefined)
+            return undefined;
+        const value = record(raw);
+        if (!value || (value.type !== "none" && value.type !== "origin" && value.type !== "session")) {
+            throw new Error("invalid callback");
+        }
+        if (value.type !== "session")
+            return { type: value.type };
+        const sessionId = requiredString(value.sessionId, "callback session");
+        if (!(await this.sessionExists(sessionId)))
+            throw new Error(`unknown session: ${sessionId}`);
+        return { type: "session", sessionId };
+    }
+    assertNoCycle(candidate) {
+        const byId = new Map(this.store.listTasks().map((task) => [task.id, task]));
+        byId.set(candidate.id, candidate);
+        const seen = new Set();
+        let task = candidate;
+        while (task?.action.type === "task") {
+            if (seen.has(task.id))
+                throw new Error("task dependency cycle");
+            seen.add(task.id);
+            task = byId.get(task.action.taskId);
+        }
+    }
+    async assertDirectory(cwd) {
+        const info = await stat(cwd).catch(() => null);
+        if (!info?.isDirectory())
+            throw new Error(`working directory does not exist: ${cwd}`);
+    }
+    changed() { this.hub.emitWorkspace({ type: "tasks-changed" }); }
+}

package/dist/tasks/execution.js

@@ -0,0 +1,141 @@
+import { logger } from "../log.js";
+import { AgentTaskRunner } from "./agent.js";
+import { TaskCallbacks } from "./callbacks.js";
+import { runBash } from "./command.js";
+import { TaskDefinitions } from "./definitions.js";
+import { TaskStore } from "./store.js";
+const log = logger("tasks");
+export class TaskExecution {
+    store;
+    definitions;
+    callbacks;
+    agent;
+    host;
+    controllers = new Map();
+    constructor(store, definitions, callbacks, agent, host) {
+        this.store = store;
+        this.definitions = definitions;
+        this.callbacks = callbacks;
+        this.agent = agent;
+        this.host = host;
+    }
+    start(run) {
+        void this.execute(run);
+    }
+    stop() {
+        for (const controller of this.controllers.values())
+            controller.abort();
+    }
+    cancel(id) {
+        log.info(`run ${id} cancel requested`);
+        this.controllers.get(id)?.abort();
+    }
+    async execute(run) {
+        const controller = new AbortController();
+        this.controllers.set(run.id, controller);
+        let timedOut = false;
+        let cause;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, run.context.definition.timeoutSeconds * 1000);
+        timeout.unref();
+        try {
+            const { definition } = run.context;
+            if (definition.trigger.type === "watch" && !run.resumedFromRunId) {
+                this.markRunning(run);
+                run.probe = await runBash(definition.trigger.script, definition.trigger.cwd, run.input, controller.signal);
+                run.matched = run.probe.exitCode === 0;
+                this.store.saveRun(run);
+                if (run.probe.exitCode === 1)
+                    run.result = { type: "watch", matched: false };
+                else if (run.probe.exitCode !== 0)
+                    throw new Error(`watch probe exited ${String(run.probe.exitCode)}`);
+            }
+            if (run.matched !== false)
+                run.result = await this.executeAction(run, controller.signal);
+            run.state = "succeeded";
+            if (definition.trigger.type === "watch" && !run.resumedFromRunId && definition.trigger.mode === "once" && run.matched) {
+                this.definitions.setEnabled(definition.id, false);
+            }
+        }
+        catch (error) {
+            // A killed child reports `exited null`, not `cancelled`: report why we
+            // aborted instead of how the corpse looked.
+            const aborted = controller.signal.aborted;
+            run.state = aborted ? (timedOut ? "failed" : "cancelled") : "failed";
+            run.error = timedOut ? "task timed out" : aborted ? "cancelled" : String(error);
+            cause = timedOut ? run.error : error;
+        }
+        finally {
+            clearTimeout(timeout);
+            run.finishedAt = Date.now();
+            const seconds = ((run.finishedAt - (run.startedAt ?? run.queuedAt)) / 1000).toFixed(1);
+            const settled = `run ${run.id} (${run.context.definition.name}) ${run.state} in ${seconds}s`;
+            // A scheduled run has no one watching it: the run row is the only other
+            // place this exists, and nobody opens the Console to find out it failed.
+            // A watch probe that did not match is the opposite case — it fires on
+            // every interval and at info would be most of the journal.
+            if (run.state === "failed")
+                log.error(settled, cause);
+            else if (run.matched === false)
+                log.debug(`${settled} (watch did not match)`);
+            else
+                log.info(settled);
+            // A run that ends awaiting a supervisor decision suppresses its
+            // completion callback: the pending question is the notification.
+            if (run.callbackSessionId && !this.host.openDecisionId(run.id))
+                run.callbackState = "pending";
+            this.store.saveRun(run);
+            this.controllers.delete(run.id);
+            this.host.changed(run);
+            this.host.settled(run);
+            if (run.callbackState === "pending")
+                void this.callbacks.deliver(run);
+        }
+    }
+    async executeAction(run, signal) {
+        const action = run.context.definition.action;
+        if (action.type === "bash") {
+            this.markRunning(run);
+            run.context.cwd = action.cwd;
+            this.store.saveRun(run);
+            const result = await runBash(action.script, action.cwd, run.input, signal);
+            const output = { type: "bash", ...result };
+            if (result.exitCode !== 0) {
+                run.result = output;
+                throw new Error(`bash exited ${String(result.exitCode)}`);
+            }
+            return output;
+        }
+        if (action.type === "task") {
+            this.markRunning(run);
+            const child = this.host.runChild(action.taskId, run);
+            let rejectWait = (reason) => { void reason; };
+            const aborted = new Promise((_, reject) => { rejectWait = reject; });
+            const onAbort = () => {
+                this.host.cancel(child.id);
+                rejectWait(new Error("cancelled"));
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            try {
+                const done = await Promise.race([this.host.waitForRun(child.id), aborted]);
+                if (done.state !== "succeeded")
+                    throw new Error(`child run ${done.state}`);
+                return { type: "task", runId: done.id, result: done.result };
+            }
+            finally {
+                signal.removeEventListener("abort", onAbort);
+            }
+        }
+        return this.agent.execute(run, action, signal, () => this.markRunning(run));
+    }
+    markRunning(run) {
+        if (run.state === "running")
+            return;
+        run.state = "running";
+        run.startedAt = Date.now();
+        this.store.saveRun(run);
+        this.host.changed(run);
+    }
+}