larkin 0.4.18 → 0.4.19

package/dist/runtime/pi-subagent-ledger.mjs

@@ -0,0 +1,594 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+export const PI_SUBAGENT_LEDGER_FILENAME = "pi-subagent-ledger.json";
+export const PI_SUBAGENT_RECORD_DIRNAME = "pi-subagent-records";
+export const PI_SUBAGENT_LEDGER_VERSION = 1;
+export const PI_SUBAGENT_SESSION_OWNER_ENV = "LARKIN_PI_SESSION_OWNER";
+export const PI_SUBAGENT_TERMINAL_NOTIFICATION_GRACE_MS = 30_000;
+const TERMINAL_STATUSES = new Set([
+    "completed",
+    "failed",
+    "cancelled",
+    "timed_out",
+    "orphaned",
+]);
+const MAX_LEDGER_TASKS = 2048;
+export function emptyDispatchedSubagentLedger() {
+    return { version: PI_SUBAGENT_LEDGER_VERSION, tasks: [] };
+}
+export function isTerminalDispatchedSubagentStatus(status) {
+    return TERMINAL_STATUSES.has(status);
+}
+export function taskIdsFromCompletionKey(completionKey) {
+    return completionKey.split("|").map((part) => part.trim()).filter(Boolean);
+}
+export function getDispatchedSubagent(ledger, taskId) {
+    return ledger.tasks.find((task) => task.taskId === taskId) ?? null;
+}
+export function noteDispatchedSubagent(ledger, input) {
+    const now = input.now ?? Date.now();
+    const existing = getDispatchedSubagent(ledger, input.taskId);
+    if (existing) {
+        if (isTerminalDispatchedSubagentStatus(existing.status))
+            return ledger;
+        return replaceTask(ledger, {
+            ...existing,
+            lastActivityAt: now,
+            ...(input.outputFile ? { outputFile: input.outputFile } : {}),
+            ...(input.recordFile ? { recordFile: input.recordFile } : {}),
+        });
+    }
+    return appendTask(ledger, {
+        taskId: input.taskId,
+        status: "dispatched",
+        dispatchedAt: now,
+        lastActivityAt: now,
+        ...(input.outputFile ? { outputFile: input.outputFile } : {}),
+        ...(input.recordFile ? { recordFile: input.recordFile } : {}),
+    });
+}
+export function noteDispatchedSubagentTerminal(ledger, input) {
+    const now = input.now ?? Date.now();
+    const status = input.status ?? "completed";
+    const existing = getDispatchedSubagent(ledger, input.taskId);
+    if (existing && isTerminalDispatchedSubagentStatus(existing.status)) {
+        return replaceTask(ledger, {
+            ...existing,
+            lastActivityAt: now,
+            ...(input.outputFile && !existing.outputFile ? { outputFile: input.outputFile } : {}),
+        });
+    }
+    const next = {
+        taskId: input.taskId,
+        status,
+        dispatchedAt: existing?.dispatchedAt ?? now,
+        lastActivityAt: now,
+        wakeState: existing?.wakeState ?? "pending",
+        ...(existing?.outputFile || input.outputFile
+            ? { outputFile: input.outputFile ?? existing?.outputFile } : {}),
+        ...(existing?.recordFile ? { recordFile: existing.recordFile } : {}),
+        ...(input.reason ? { reason: input.reason } : existing?.reason ? { reason: existing.reason } : {}),
+        ...(input.wakeKey ? { wakeKey: input.wakeKey } : existing?.wakeKey ? { wakeKey: existing.wakeKey } : {}),
+    };
+    return existing ? replaceTask(ledger, next) : appendTask(ledger, next);
+}
+export function noteDispatchedSubagentActivity(ledger, input) {
+    const existing = getDispatchedSubagent(ledger, input.taskId);
+    if (!existing || isTerminalDispatchedSubagentStatus(existing.status))
+        return ledger;
+    return replaceTask(ledger, {
+        ...existing,
+        lastActivityAt: input.now ?? Date.now(),
+        ...(input.outputFile ? { outputFile: input.outputFile } : {}),
+    });
+}
+export function markDispatchedSubagentOrphaned(ledger, input) {
+    const existing = getDispatchedSubagent(ledger, input.taskId);
+    if (existing && isTerminalDispatchedSubagentStatus(existing.status)) {
+        return { ledger, record: null };
+    }
+    const now = input.now ?? Date.now();
+    const record = {
+        taskId: input.taskId,
+        status: "orphaned",
+        dispatchedAt: existing?.dispatchedAt ?? now,
+        lastActivityAt: existing?.lastActivityAt ?? now,
+        reason: input.reason,
+        wakeKey: input.taskId,
+        wakeState: "pending",
+        ...(input.outputFile || existing?.outputFile
+            ? { outputFile: input.outputFile ?? existing?.outputFile } : {}),
+        ...(existing?.recordFile ? { recordFile: existing.recordFile } : {}),
+    };
+    return {
+        ledger: existing ? replaceTask(ledger, record) : appendTask(ledger, record),
+        record,
+    };
+}
+export function reconcileDispatchedSubagents(ledger, input = {}) {
+    const now = input.now ?? Date.now();
+    const orphaned = [];
+    const terminals = [];
+    let next = ledger;
+    for (const task of ledger.tasks) {
+        if (isTerminalDispatchedSubagentStatus(task.status))
+            continue;
+        const current = getDispatchedSubagent(next, task.taskId) ?? task;
+        const refreshed = refreshActivityFromOutput(current, now);
+        if (refreshed.lastActivityAt !== current.lastActivityAt) {
+            next = noteDispatchedSubagentActivity(next, {
+                taskId: current.taskId,
+                outputFile: refreshed.outputFile,
+                now: refreshed.lastActivityAt,
+            });
+        }
+        const probed = getDispatchedSubagent(next, current.taskId) ?? refreshed;
+        const probedPresence = input.probe?.(probed);
+        const presence = input.forceMissing
+            ? (probedPresence === "consumed" || probedPresence === "terminal" ? probedPresence : "absent")
+            : (probedPresence ?? "present");
+        if (presence === "consumed") {
+            next = noteConsumedDispatchedSubagent(next, {
+                taskId: current.taskId,
+                status: readConsumedPiSubagentTerminal(current.recordFile)?.status ?? "completed",
+                outputFile: current.outputFile,
+                now,
+            });
+            retireConsumedPiSubagentRecord(current.recordFile);
+            continue;
+        }
+        if (presence === "terminal") {
+            if (!input.forceMissing && !hasTerminalNotificationGraceElapsed(current.recordFile, now))
+                continue;
+            next = noteDispatchedSubagentTerminal(next, {
+                taskId: current.taskId,
+                status: readPersistedPiSubagentTerminal(current.recordFile)?.status ?? "completed",
+                outputFile: current.outputFile,
+                wakeKey: current.taskId,
+                now,
+            });
+            const advanced = getDispatchedSubagent(next, current.taskId);
+            if (advanced)
+                terminals.push(advanced);
+            continue;
+        }
+        if (presence !== "absent")
+            continue;
+        const marked = markDispatchedSubagentOrphaned(next, {
+            taskId: current.taskId,
+            reason: input.missingReason ?? (input.forceMissing ? "pi session gone" : "pi record missing"),
+            outputFile: current.outputFile,
+            now,
+        });
+        next = marked.ledger;
+        if (marked.record)
+            orphaned.push(marked.record);
+    }
+    return { ledger: next, orphaned, terminals };
+}
+export function noteDispatchedSubagentWakeAcknowledged(ledger, input) {
+    const now = input.now ?? Date.now();
+    let next = ledger;
+    for (const taskId of taskIdsFromCompletionKey(input.completionKey)) {
+        const existing = getDispatchedSubagent(next, taskId);
+        if (!existing || !isTerminalDispatchedSubagentStatus(existing.status))
+            continue;
+        if (existing.wakeState === "acknowledged")
+            continue;
+        next = replaceTask(next, { ...existing, wakeState: "acknowledged", notifiedAt: now });
+    }
+    return next;
+}
+export function undeliveredTerminalWakeKeys(ledger) {
+    const seen = new Set();
+    const keys = [];
+    for (const task of ledger.tasks) {
+        if (!needsTerminalWake(task))
+            continue;
+        const key = task.wakeKey ?? task.taskId;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        keys.push(key);
+    }
+    return keys;
+}
+export function noteConsumedDispatchedSubagent(ledger, input) {
+    const now = input.now ?? Date.now();
+    const next = noteDispatchedSubagentTerminal(ledger, {
+        taskId: input.taskId,
+        status: input.status ?? "completed",
+        outputFile: input.outputFile,
+        wakeKey: input.taskId,
+        now,
+    });
+    return noteDispatchedSubagentWakeAcknowledged(next, { completionKey: input.taskId, now });
+}
+export function isTerminalPiSubagentRecord(record) {
+    if (!record || typeof record !== "object")
+        return false;
+    const status = record.status;
+    return typeof status === "string" && status.length > 0
+        && status !== "running" && status !== "queued";
+}
+export function isConsumedTerminalPiSubagentRecord(record) {
+    if (!isTerminalPiSubagentRecord(record))
+        return false;
+    return record.resultConsumed === true;
+}
+export function ledgerStatusFromPiSubagentRecord(record) {
+    const status = typeof record === "object" && record && "status" in record
+        ? String(record.status || "").trim().toLowerCase()
+        : "";
+    if (status === "error")
+        return "failed";
+    if (status === "aborted")
+        return "timed_out";
+    if (status === "stopped")
+        return "cancelled";
+    if (status === "steered")
+        return "timed_out";
+    return "completed";
+}
+export function readPersistedPiSubagentTerminal(file) {
+    return readPiSubagentTerminalFile(file, false);
+}
+export function readConsumedPiSubagentTerminal(file) {
+    return readPiSubagentTerminalFile(file, true);
+}
+export function writePersistedPiSubagentTerminal(file, input, options) {
+    writePiSubagentTerminalFile(file, input, options?.resultConsumed === true);
+}
+export function writeConsumedPiSubagentTerminal(file, input) {
+    writePersistedPiSubagentTerminal(file, input, { resultConsumed: true });
+}
+export function retirePiSubagentRecord(file) {
+    if (!file)
+        return false;
+    try {
+        const stat = fs.lstatSync(file);
+        if (stat.isSymbolicLink() || !stat.isFile())
+            return false;
+        fs.unlinkSync(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function retireConsumedPiSubagentRecord(file) {
+    if (!file || !readConsumedPiSubagentTerminal(file))
+        return false;
+    return retirePiSubagentRecord(file);
+}
+/** Probe the Pi task record sidecar. A leftover transcript is never presence. */
+export function probePiSubagentRecord(record) {
+    if (!record.recordFile)
+        return "absent";
+    try {
+        const stat = fs.lstatSync(record.recordFile);
+        if (stat.isSymbolicLink() || !stat.isFile())
+            return "absent";
+        if (readConsumedPiSubagentTerminal(record.recordFile))
+            return "consumed";
+        if (readPersistedPiSubagentTerminal(record.recordFile))
+            return "terminal";
+        return "present";
+    }
+    catch {
+        return "absent";
+    }
+}
+/** @deprecated Use probePiSubagentRecord. Transcript leftovers are not presence. */
+export function probePiSubagentOutputRecord(record) {
+    return probePiSubagentRecord(record);
+}
+/** Same implicit root the Pi adapter uses when `stateDir` is omitted. */
+export function effectivePiStateDir(input) {
+    return input.stateDir ?? path.join(input.workspaceDir, ".larkin");
+}
+export function dispatchedSubagentRecordDir(stateDir) {
+    return path.join(stateDir, PI_SUBAGENT_RECORD_DIRNAME);
+}
+export function dispatchedSubagentRecordFile(stateDir, taskId) {
+    return path.join(dispatchedSubagentRecordDir(stateDir), taskId);
+}
+export function writeDispatchedSubagentRecordFile(stateDir, taskId, owner) {
+    if (!stateDir || !taskId)
+        return undefined;
+    const dir = dispatchedSubagentRecordDir(stateDir);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const file = dispatchedSubagentRecordFile(stateDir, taskId);
+    const existing = (() => { try {
+        return fs.lstatSync(file);
+    }
+    catch {
+        return null;
+    } })();
+    if (existing?.isSymbolicLink())
+        throw new Error("subagent record file must not be a symlink");
+    const normalizedOwner = typeof owner === "string" && owner.trim() ? owner.trim() : undefined;
+    fs.writeFileSync(file, `${JSON.stringify({
+        taskId,
+        ...(normalizedOwner ? { owner: normalizedOwner } : {}),
+    })}\n`, { mode: 0o600 });
+    fs.chmodSync(file, 0o600);
+    return file;
+}
+export function sweepAbsentPiSubagentRecordFiles(recordDir, getRecord, options) {
+    let names;
+    try {
+        names = fs.readdirSync(recordDir);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const removed = [];
+    for (const name of names) {
+        if (!name || name.startsWith("."))
+            continue;
+        const file = path.join(recordDir, name);
+        try {
+            const stat = fs.lstatSync(file);
+            if (stat.isSymbolicLink() || !stat.isFile())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const owner = typeof options?.owner === "string" && options.owner.trim() ? options.owner.trim() : undefined;
+        if (owner && readPiSubagentRecordOwner(file) !== owner)
+            continue;
+        const record = getRecord(name);
+        if (isTerminalPiSubagentRecord(record)) {
+            try {
+                // Unchanged terminal payloads must not be rewritten: mtime is the
+                // 30s lost-notification grace clock while Pi still holds the record.
+                writePersistedPiSubagentTerminal(file, {
+                    taskId: name,
+                    status: ledgerStatusFromPiSubagentRecord(record),
+                }, { resultConsumed: isConsumedTerminalPiSubagentRecord(record) });
+            }
+            catch {
+                // Keep the sidecar; the next sweep retries the terminal bridge.
+            }
+            continue;
+        }
+        if (record != null)
+            continue;
+        if (readPersistedPiSubagentTerminal(file))
+            continue;
+        try {
+            fs.unlinkSync(file);
+            removed.push(name);
+        }
+        catch {
+            // Best-effort: the next sweep retries.
+        }
+    }
+    return removed;
+}
+export function ledgerFilePath(stateDir) {
+    return stateDir ? path.join(stateDir, PI_SUBAGENT_LEDGER_FILENAME) : null;
+}
+export function readDispatchedSubagentLedger(file) {
+    if (!file)
+        return emptyDispatchedSubagentLedger();
+    try {
+        const stat = fs.lstatSync(file);
+        if (stat.isSymbolicLink() || !stat.isFile())
+            throw new Error("subagent ledger is not a regular file");
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        return normalizeLedger(parsed);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return emptyDispatchedSubagentLedger();
+        throw error;
+    }
+}
+export function writeDispatchedSubagentLedger(file, ledger) {
+    if (!file)
+        return;
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const existing = (() => { try {
+        return fs.lstatSync(file);
+    }
+    catch {
+        return null;
+    } })();
+    if (existing?.isSymbolicLink())
+        throw new Error("subagent ledger must not be a symlink");
+    const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+    fs.writeFileSync(temporary, `${JSON.stringify(normalizeLedger(ledger), null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, file);
+    fs.chmodSync(file, 0o600);
+}
+export function extractBackgroundPiSubagentDispatch(event) {
+    if (event.isError === true)
+        return null;
+    if (String(event.toolName || "") !== "Agent")
+        return null;
+    const args = asRecord(event.args);
+    const resultText = collectResultText(event.result);
+    const details = asRecord(asRecord(event.result)?.details);
+    const backgroundByArgs = args?.run_in_background === true;
+    const backgroundByResult = /Agent (?:started|queued) in background/i.test(resultText);
+    if (!backgroundByArgs && !backgroundByResult)
+        return null;
+    const taskId = firstNonEmpty(stringValue(details?.agentId), stringValue(details?.id), matchCapture(resultText, /Agent ID:\s*(\S+)/i));
+    if (!taskId)
+        return null;
+    const outputFile = firstNonEmpty(stringValue(details?.outputFile), matchCapture(resultText, /Output file:\s*(.+)/i));
+    return outputFile ? { taskId, outputFile } : { taskId };
+}
+function readPiSubagentTerminalFile(file, requireConsumed) {
+    if (!file)
+        return null;
+    try {
+        const stat = fs.lstatSync(file);
+        if (stat.isSymbolicLink() || !stat.isFile())
+            return null;
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        if (requireConsumed && parsed.resultConsumed !== true && parsed.consumed !== true)
+            return null;
+        if (typeof parsed.taskId !== "string" || parsed.taskId.length === 0)
+            return null;
+        if (parsed.status !== "completed" && parsed.status !== "failed"
+            && parsed.status !== "cancelled" && parsed.status !== "timed_out") {
+            return null;
+        }
+        return { taskId: parsed.taskId, status: parsed.status };
+    }
+    catch {
+        return null;
+    }
+}
+function writePiSubagentTerminalFile(file, input, resultConsumed) {
+    const existing = (() => { try {
+        return fs.lstatSync(file);
+    }
+    catch {
+        return null;
+    } })();
+    if (existing?.isSymbolicLink())
+        throw new Error("subagent record file must not be a symlink");
+    const owner = readPiSubagentRecordOwner(file);
+    const payload = `${JSON.stringify({
+        taskId: input.taskId,
+        ...(resultConsumed ? { resultConsumed: true } : {}),
+        status: input.status,
+        ...(owner ? { owner } : {}),
+    })}\n`;
+    if (existing?.isFile()) {
+        try {
+            if (fs.readFileSync(file, "utf8") === payload)
+                return;
+        }
+        catch {
+            // Rewrite if the existing sidecar cannot be compared.
+        }
+    }
+    fs.writeFileSync(file, payload, { mode: 0o600 });
+    fs.chmodSync(file, 0o600);
+}
+function hasTerminalNotificationGraceElapsed(file, now) {
+    if (!file)
+        return true;
+    try {
+        const mtimeMs = fs.statSync(file).mtimeMs;
+        return Number.isFinite(mtimeMs) && now - mtimeMs >= PI_SUBAGENT_TERMINAL_NOTIFICATION_GRACE_MS;
+    }
+    catch {
+        return true;
+    }
+}
+function refreshActivityFromOutput(task, now) {
+    if (!task.outputFile)
+        return task;
+    try {
+        const mtimeMs = fs.statSync(task.outputFile).mtimeMs;
+        if (Number.isFinite(mtimeMs) && mtimeMs > task.lastActivityAt) {
+            return { ...task, lastActivityAt: Math.min(now, Math.floor(mtimeMs)) };
+        }
+    }
+    catch {
+        // Missing output files are handled by the probe, not activity refresh.
+    }
+    return task;
+}
+function normalizeLedger(value) {
+    const tasks = Array.isArray(value?.tasks) ? value.tasks.filter(isPersistedTask) : [];
+    return { version: PI_SUBAGENT_LEDGER_VERSION, tasks: capLedgerTasks(tasks) };
+}
+function isAcknowledgedTerminalTask(task) {
+    return isTerminalDispatchedSubagentStatus(task.status) && task.wakeState === "acknowledged";
+}
+function capLedgerTasks(tasks) {
+    if (tasks.length <= MAX_LEDGER_TASKS)
+        return tasks;
+    const overflow = tasks.length - MAX_LEDGER_TASKS;
+    const evict = new Set();
+    for (let index = 0; index < tasks.length && evict.size < overflow; index += 1) {
+        if (isAcknowledgedTerminalTask(tasks[index]))
+            evict.add(index);
+    }
+    if (evict.size === 0)
+        return tasks;
+    return tasks.filter((_, index) => !evict.has(index));
+}
+function readPiSubagentRecordOwner(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        return typeof parsed?.owner === "string" && parsed.owner.trim() ? parsed.owner.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isPersistedTask(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return typeof record.taskId === "string" && record.taskId.length > 0
+        && typeof record.status === "string"
+        && ["dispatched", "completed", "failed", "cancelled", "timed_out", "orphaned"].includes(record.status)
+        && Number.isFinite(record.dispatchedAt)
+        && Number.isFinite(record.lastActivityAt)
+        && (record.recordFile === undefined || (typeof record.recordFile === "string" && record.recordFile.length > 0))
+        && (record.wakeState === undefined || record.wakeState === "pending" || record.wakeState === "acknowledged");
+}
+function needsTerminalWake(task) {
+    if (!isTerminalDispatchedSubagentStatus(task.status))
+        return false;
+    if (task.wakeState === "acknowledged")
+        return false;
+    if (task.wakeState === "pending")
+        return true;
+    return task.notifiedAt == null;
+}
+function appendTask(ledger, record) {
+    return normalizeLedger({ version: PI_SUBAGENT_LEDGER_VERSION, tasks: [...ledger.tasks, record] });
+}
+function replaceTask(ledger, record) {
+    return {
+        version: PI_SUBAGENT_LEDGER_VERSION,
+        tasks: ledger.tasks.map((task) => task.taskId === record.taskId ? record : task),
+    };
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function firstNonEmpty(...values) {
+    return values.find((value) => Boolean(value)) ?? null;
+}
+function matchCapture(text, pattern) {
+    const match = pattern.exec(text);
+    return match?.[1] ? match[1].trim() : null;
+}
+function collectResultText(result) {
+    if (typeof result === "string")
+        return result;
+    const record = asRecord(result);
+    if (!record)
+        return "";
+    if (typeof record.content === "string")
+        return record.content;
+    if (Array.isArray(record.content)) {
+        return record.content.map((part) => {
+            if (typeof part === "string")
+                return part;
+            const item = asRecord(part);
+            return typeof item?.text === "string" ? item.text : "";
+        }).join("\n");
+    }
+    return typeof record.text === "string" ? record.text : "";
+}

package/dist/runtime/pi-subagent-record-watchdog-injection.mjs

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { piVersionSupportsSubagents, probeExternalPiVersion } from "./pi-subagent-injection.mjs";
+export function materializeEmbeddedPiSubagentRecordWatchdogBundle(configDir) {
+    const embedded = globalThis.__LARKIN_EMBEDDED_PI_SUBAGENT_RECORD_WATCHDOG_BUNDLE__;
+    if (!embedded || !configDir)
+        return null;
+    const dir = path.join(path.resolve(configDir), "providers", "pi", "extensions");
+    const target = path.join(dir, "pi-subagent-record-watchdog.bundle.js");
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.chmodSync(dir, 0o700);
+        if (!fs.existsSync(target) || fs.readFileSync(target, "utf8") !== embedded) {
+            const temporary = `${target}.${process.pid}.tmp`;
+            fs.writeFileSync(temporary, embedded, { mode: 0o600, flag: "wx" });
+            fs.renameSync(temporary, target);
+            fs.chmodSync(target, 0o600);
+        }
+        return target;
+    }
+    catch {
+        return null;
+    }
+}
+export function bundledPiSubagentRecordWatchdogExtensionPath(configDir) {
+    try {
+        const url = new URL("./pi-subagent-record-watchdog.bundle.js", import.meta.url);
+        const resolved = fileURLToPath(url);
+        if (fs.existsSync(resolved))
+            return resolved;
+    }
+    catch {
+        /* fall through to embedded */
+    }
+    return materializeEmbeddedPiSubagentRecordWatchdogBundle(configDir);
+}
+export function resolvePiSubagentRecordWatchdogExtensionArg(input, probeVersion = () => probeExternalPiVersion(input.piCommand, input.env), resolveBundle = () => bundledPiSubagentRecordWatchdogExtensionPath(input.env.LARKIN_CONFIG_DIR)) {
+    const bundle = resolveBundle();
+    if (!bundle)
+        return null;
+    return piVersionSupportsSubagents(probeVersion()) ? bundle : null;
+}