@indigoai-us/hq-cli 5.167.0 → 5.169.0

package/dist/commands/lanes.js

@@ -10,6 +10,7 @@ import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { resolveProcessFlagGate } from "../lib/flag-registry.js";
@@ -1339,13 +1340,23 @@ async function emitLaneTerminalStateSoft(ctx, lane) {
     }
 }
 async function emitLaneStartedForStories(ctx, company, lane, threadId) {
-    const ready = ctx.mesh.ensureLaneThread
-        ? await ensureLaneThreadRecord(ctx, lane, lane.project_id, lane.story_id, "running")
-        : lane;
+    let ready = lane;
+    if (ctx.mesh.ensureLaneThread) {
+        try {
+            ready = await ensureLaneThreadRecord(ctx, lane, lane.project_id, lane.story_id, "running");
+        }
+        catch (err) {
+            const warning = storyNotOnBoardWarning(err);
+            if (warning !== undefined)
+                return [warning];
+            throw err;
+        }
+    }
     const stableThreadId = ready.thread_id ?? threadId;
     if (!stableThreadId)
-        return;
+        return [];
     const failures = [];
+    const warnings = [];
     for (const story of laneStories(ready)) {
         try {
             await emitLaneMeshEvent(ctx, company, stableThreadId, "lane_started", {
@@ -1354,14 +1365,59 @@ async function emitLaneStartedForStories(ctx, company, lane, threadId) {
                 project_id: story.project_id,
                 story_id: story.story_id,
             });
-            await ctx.mesh.patchStoryStatus(company, story.project_id, story.story_id, "in_progress");
         }
         catch (err) {
+            const warning = storyNotOnBoardWarning(err);
+            if (warning !== undefined) {
+                warnings.push(warning);
+                continue;
+            }
             failures.push(err);
+            continue;
+        }
+        try {
+            await ctx.mesh.patchStoryStatus(company, story.project_id, story.story_id, "in_progress");
+        }
+        catch (err) {
+            const warning = storyNotOnBoardWarning(err);
+            if (warning !== undefined)
+                warnings.push(warning);
+            else
+                failures.push(err);
         }
     }
     if (failures.length > 0)
         throw failures[0];
+    return warnings;
+}
+async function assertStoriesOnBoard(ctx, company, projectId, storyIds) {
+    const check = ctx.mesh.assertProjectStoriesOnBoard;
+    if (!check) {
+        throw new LanesError("story_board_check_unavailable", "Cannot confirm stories are on the Work Mesh Board; refusing to write lane state", { project_id: projectId, story_id: storyIds[0] ?? null });
+    }
+    await check.call(ctx.mesh, company, projectId, storyIds);
+}
+function storyNotOnBoardWarning(err) {
+    return isLanesError(err) && err.error === "story_not_on_board"
+        ? err.message
+        : undefined;
+}
+function combinedStoryWarning(lane, additional = []) {
+    const warnings = [storyWarning(lane), ...additional]
+        .filter((warning) => warning !== undefined && warning.trim().length > 0);
+    return [...new Set(warnings)].join(" ") || null;
+}
+async function storyBoardWarning(ctx, company, projectId, storyIds) {
+    try {
+        await assertStoriesOnBoard(ctx, company, projectId, storyIds);
+        return undefined;
+    }
+    catch (err) {
+        const warning = storyNotOnBoardWarning(err);
+        if (warning !== undefined)
+            return warning;
+        throw err;
+    }
 }
 export const PICKUP_TERMINAL_REASONS = [
     "account_not_logged_in",
@@ -1630,6 +1686,12 @@ async function runCreate(ctx, opts) {
     }
     const seniorCompany = companyOfSenior(hqRoot, senior, ctx);
     assertSameTenant(company, senior, seniorCompany);
+    const createStoryWarnings = [];
+    if (meshCompany) {
+        const warning = await storyBoardWarning(ctx, meshCompany, project, storyIds);
+        if (warning !== undefined)
+            createStoryWarnings.push(warning);
+    }
     let resolvedWorker;
     if (opts.worker) {
         resolvedWorker = resolveLaneWorker(hqRoot, opts.worker, company?.slug);
@@ -2078,19 +2140,25 @@ async function runCreate(ctx, opts) {
         try {
             lane = await ensureLaneThreadRecord(ctx, lane);
         }
-        catch {
-            try {
-                lane = casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => ({
-                    ...current,
-                    state: "failed",
-                    queued_reason: undefined,
-                    terminal_reason: "mesh_thread_registration_failed",
-                }));
+        catch (err) {
+            const warning = storyNotOnBoardWarning(err);
+            if (warning !== undefined) {
+                createStoryWarnings.push(warning);
             }
-            catch {
-                throw new LanesError("mesh_thread_registration_failed", `Work Mesh lane registration failed for ${lane.lane_id}, and its local record could not be marked terminal.`, { lane_id: lane.lane_id });
+            else {
+                try {
+                    lane = casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => ({
+                        ...current,
+                        state: "failed",
+                        queued_reason: undefined,
+                        terminal_reason: "mesh_thread_registration_failed",
+                    }));
+                }
+                catch {
+                    throw new LanesError("mesh_thread_registration_failed", `Work Mesh lane registration failed for ${lane.lane_id}, and its local record could not be marked terminal.`, { lane_id: lane.lane_id });
+                }
+                throw new LanesError("mesh_thread_registration_failed", `Work Mesh lane registration failed; lane ${lane.lane_id} was marked failed.`, { lane_id: lane.lane_id, state: lane.state });
             }
-            throw new LanesError("mesh_thread_registration_failed", `Work Mesh lane registration failed; lane ${lane.lane_id} was marked failed.`, { lane_id: lane.lane_id, state: lane.state });
         }
     }
     // Thread registration runs after persistence; anchor the reservation after
@@ -2136,8 +2204,9 @@ async function runCreate(ctx, opts) {
             runCompaction: ctx.runCompaction,
             locateTranscript: ctx.locateTranscript,
         });
-        if (meshCompany)
-            await emitLaneStartedForStories(ctx, meshCompany, started, started.thread_id);
+        if (meshCompany) {
+            createStoryWarnings.push(...await emitLaneStartedForStories(ctx, meshCompany, started, started.thread_id));
+        }
     }
     else if (outpostId) {
         started = await dispatchCreatedOutpostLane(ctx, {
@@ -2173,7 +2242,7 @@ async function runCreate(ctx, opts) {
         project_id: started.project_id,
         story_id: started.story_id,
         stories: laneStories(started),
-        story_warning: storyWarning(started) ?? null,
+        story_warning: combinedStoryWarning(started, createStoryWarnings),
         thread_id: started.thread_id ?? null,
         senior: started.senior,
         depth: started.depth,
@@ -4137,6 +4206,17 @@ async function ensureStoryThread(ctx, lane, projectId, storyId = lane.story_id)
         return lane;
     return ensureLaneThreadRecord(ctx, lane, projectId, storyId);
 }
+async function ensureStoryThreadForTransition(ctx, lane, projectId, storyId) {
+    try {
+        return { lane: await ensureStoryThread(ctx, lane, projectId, storyId) };
+    }
+    catch (err) {
+        const warning = storyNotOnBoardWarning(err);
+        if (warning === undefined)
+            throw err;
+        return { lane, warning };
+    }
+}
 async function ensureLaneThreadRecord(ctx, lane, projectId = lane.project_id, storyId = lane.story_id, laneStatus = lane.state) {
     const company = lane.mesh_company ?? lane.company;
     if (!company)
@@ -4184,8 +4264,12 @@ function sameCommittedStory(current, expected, projectId, storyId) {
 async function commitStoryTransition(ctx, before, next, projectId, storyId, event, status, payload = {}) {
     try {
         await emitStoryTransition(ctx, next, projectId, storyId, event, status, payload);
+        return undefined;
     }
     catch (err) {
+        const warning = storyNotOnBoardWarning(err);
+        if (warning !== undefined)
+            return warning;
         try {
             const current = readLane(ctx.hqRoot(), next.lane_id);
             if (!sameCommittedStory(current, next, projectId, storyId)) {
@@ -4230,14 +4314,26 @@ async function runStoryAdd(ctx, laneId, storyId, opts) {
     const normalizedStoryId = storyId.trim();
     if (!normalizedStoryId)
         throw new LanesError("missing_story", "<story-id> is required", {});
+    const company = lane.mesh_company ?? lane.company;
+    const warnings = [];
+    if (company) {
+        const warning = await storyBoardWarning(ctx, company, projectId, [normalizedStoryId]);
+        if (warning !== undefined)
+            warnings.push(warning);
+    }
     const at = ctx.now().toISOString();
-    lane = await ensureStoryThread(ctx, lane, projectId);
+    const thread = await ensureStoryThreadForTransition(ctx, lane, projectId, normalizedStoryId);
+    lane = thread.lane;
+    if (thread.warning !== undefined)
+        warnings.push(thread.warning);
     const before = lane;
     const next = casUpdateLane(hqRoot, laneId, (current) => {
         assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
         return addCarriedStory(current, projectId, normalizedStoryId, at);
     });
-    await commitStoryTransition(ctx, before, next, projectId, normalizedStoryId, "lane_started", "in_progress");
+    const transitionWarning = await commitStoryTransition(ctx, before, next, projectId, normalizedStoryId, "lane_started", "in_progress");
+    if (transitionWarning !== undefined)
+        warnings.push(transitionWarning);
     const finalLane = readLane(hqRoot, laneId);
     printJson({
         ok: true,
@@ -4246,7 +4342,7 @@ async function runStoryAdd(ctx, laneId, storyId, opts) {
         project_id: projectId,
         story_id: normalizedStoryId,
         status: "in_progress",
-        story_warning: storyWarning(finalLane) ?? null,
+        story_warning: combinedStoryWarning(finalLane, warnings),
         lane: finalLane,
     });
 }
@@ -4263,15 +4359,21 @@ async function runStoryStart(ctx, laneId, storyId, opts) {
         });
     }
     const at = ctx.now().toISOString();
-    lane = await ensureStoryThread(ctx, lane, target.projectId);
+    const warnings = [];
+    const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
+    lane = thread.lane;
+    if (thread.warning !== undefined)
+        warnings.push(thread.warning);
     const before = lane;
     const next = casUpdateLane(hqRoot, laneId, (current) => {
         assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
         return updateCarriedStory(current, target.projectId, target.storyId, "in_progress", at);
     });
-    await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_started", "in_progress");
+    const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_started", "in_progress");
+    if (transitionWarning !== undefined)
+        warnings.push(transitionWarning);
     const finalLane = readLane(hqRoot, laneId);
-    printJson({ ok: true, action: "story.start", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "in_progress", story_warning: storyWarning(finalLane) ?? null, lane: finalLane });
+    printJson({ ok: true, action: "story.start", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "in_progress", story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
 }
 async function runStoryBlock(ctx, laneId, storyId, opts) {
     const hqRoot = ctx.hqRoot();
@@ -4289,15 +4391,21 @@ async function runStoryBlock(ctx, laneId, storyId, opts) {
     if (!reason)
         throw new LanesError("missing_block_reason", "--reason is required", {});
     const at = ctx.now().toISOString();
-    lane = await ensureStoryThread(ctx, lane, target.projectId);
+    const warnings = [];
+    const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
+    lane = thread.lane;
+    if (thread.warning !== undefined)
+        warnings.push(thread.warning);
     const before = lane;
     const next = casUpdateLane(hqRoot, laneId, (current) => {
         assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
         return updateCarriedStory(current, target.projectId, target.storyId, "blocked", at, { blocked_reason: reason });
     });
-    await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_blocked", "blocked", { blocked_reason: reason });
+    const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_blocked", "blocked", { blocked_reason: reason });
+    if (transitionWarning !== undefined)
+        warnings.push(transitionWarning);
     const finalLane = readLane(hqRoot, laneId);
-    printJson({ ok: true, action: "story.block", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "blocked", blocked_reason: reason, story_warning: storyWarning(finalLane) ?? null, lane: finalLane });
+    printJson({ ok: true, action: "story.block", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "blocked", blocked_reason: reason, story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
 }
 async function runStoryDone(ctx, laneId, storyId, opts) {
     const hqRoot = ctx.hqRoot();
@@ -4322,7 +4430,11 @@ async function runStoryDone(ctx, laneId, storyId, opts) {
         });
     }
     const at = ctx.now().toISOString();
-    lane = await ensureStoryThread(ctx, lane, target.projectId);
+    const warnings = [];
+    const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
+    lane = thread.lane;
+    if (thread.warning !== undefined)
+        warnings.push(thread.warning);
     const before = lane;
     const next = casUpdateLane(hqRoot, laneId, (current) => {
         assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
@@ -4331,9 +4443,11 @@ async function runStoryDone(ctx, laneId, storyId, opts) {
             verified_by: current.senior,
         });
     });
-    await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_done", "done", { summary: "Senior verification complete" });
+    const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_done", "done", { summary: "Senior verification complete" });
+    if (transitionWarning !== undefined)
+        warnings.push(transitionWarning);
     const finalLane = readLane(hqRoot, laneId);
-    printJson({ ok: true, action: "story.done", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "done", verified: true, story_warning: storyWarning(finalLane) ?? null, lane: finalLane });
+    printJson({ ok: true, action: "story.done", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "done", verified: true, story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
 }
 /**
  * Registration state of the drain hook in the lane's account home, read the
@@ -5385,6 +5499,7 @@ export function registerLanesCommand(parent, deps = {}) {
     const lanes = parent
         .command("lanes", { hidden: true })
         .description("Create, supervise, and steer worker lanes; routed decision queue");
+    registerOutpostPrunerCommand(lanes);
     lanes
         .command("create")
         .description("Register a lane, run admission, and return immediately")

package/dist/commands/mesh.js

@@ -14,7 +14,7 @@ import chalk from "chalk";
 import { loadCachedTokens, isMachineIdentity } from "../utils/cognito-session.js";
 import * as readline from "node:readline/promises";
 import { STORY_STATUSES, appendThreadEvent, ensureProjectThread, eventPayload, getProjectView, listActiveMembershipCompanies, listActiveThreads, patchStory, putProjectView, registerMeshProject, resolveActiveMembershipCompany, resolveMeshPrincipalUid, warmMeshConversationCache, } from "../lib/mesh/api.js";
-import { closeSupersededProjectThread, ensureMissingBoardStories, ensureProjectBoard } from "../lib/mesh/project-board.js";
+import { closeSupersededProjectThread, ensureMissingBoardStories, ensureProjectBoard, formatStoryStatusChanges, mergeProjectStories, } from "../lib/mesh/project-board.js";
 import { buildPreflightFixtures } from "../lib/work-context/preflight-contract.js";
 import { createCandidatesFetcher, createMigratePoster, createOrganizePoster, createWorkSessionDeliverer, fetchCompanyLive, formatCompanyLiveTable, openMeshTransport, probeMigrationCapabilityForMemberships, requireToken, } from "../lib/mesh/client.js";
 import { clearDefaultCompany, isDefaultCompanyDisabled, readDeviceConfig, recordMigrationCapabilitySnapshot, setRepairHeldWithDefault, setDefaultCompany, } from "../lib/work-context/config.js";
@@ -307,23 +307,6 @@ function httpStatus(err) {
     }
     return undefined;
 }
-function mergeProjectStories(current, planned) {
-    const currentById = new Map(current.map((story) => [story.id, story]));
-    const plannedIds = new Set(planned.map((story) => story.id));
-    const merged = planned.map((story) => {
-        const live = currentById.get(story.id);
-        if (!live)
-            return story;
-        const status = live.status || story.status;
-        return {
-            ...story,
-            ...(status ? { status } : {}),
-            passes: status === "done" ? true : typeof live.passes === "boolean" ? live.passes : story.passes,
-            ...(live.assigneeUid ? { assigneeUid: live.assigneeUid } : {}),
-        };
-    });
-    return [...merged, ...current.filter((story) => !plannedIds.has(story.id))];
-}
 function mergeProjectRepos(current, planned) {
     const plannedPaths = new Set(planned.map((repo) => repo.path));
     return [...planned, ...current.filter((repo) => !plannedPaths.has(repo.path))];
@@ -386,6 +369,10 @@ async function runProjectSet(projectId, opts) {
         registration = ensured.registration;
     }
     else if (opts.name !== undefined || opts.description !== undefined || source !== undefined || explicitRepos !== undefined) {
+        const stories = source
+            ? mergeProjectStories(current.stories, source.stories, { resetStatus: Boolean(opts.resetStatus) })
+            : current.stories;
+        const statusChangeLine = source ? formatStoryStatusChanges(current.stories, stories) : undefined;
         try {
             view = await putProjectView(token, company.companyUid, projectId, {
                 name: opts.name?.trim() || source?.name || current.name,
@@ -394,7 +381,7 @@ async function runProjectSet(projectId, opts) {
                     : source?.description !== undefined
                         ? { description: source.description }
                         : { description: current.description }),
-                stories: source?.stories ?? current.stories,
+                stories,
                 repos: explicitRepos ?? source?.repos ?? current.repos,
                 ...(current.version !== undefined ? { expectedVersion: current.version } : {}),
             });
@@ -409,6 +396,12 @@ async function runProjectSet(projectId, opts) {
             }
             throw err;
         }
+        if (statusChangeLine) {
+            if (opts.json)
+                console.error(statusChangeLine);
+            else
+                console.log(statusChangeLine);
+        }
     }
     else {
         view = current;
@@ -1816,6 +1809,7 @@ export function registerMeshCommand(program) {
         .option("--repo <path[@branch]>", "Repository binding (repeatable)", collectRepeatable)
         .option("--channel <channelId>", "Bind the project to an existing company or project channel")
         .option("--create", "Create the Board view when the GET is a 404")
+        .option("--reset-status", "Overwrite live story status from the PRD (prints a one-line summary of changes)")
         .option("--json", "Print machine-readable JSON")
         .action((projectId, opts) => wrap(() => runProjectSet(projectId, opts))());
     project

package/dist/commands/outpost-pruner.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function registerOutpostPrunerCommand(lanes: Command): void;
+//# sourceMappingURL=outpost-pruner.d.ts.map

package/dist/commands/outpost-pruner.js

@@ -0,0 +1,125 @@
+import { spawnSync } from "node:child_process";
+import * as os from "node:os";
+import * as path from "node:path";
+import { outpostWorktreePrunerEnabled, OUTPOST_WORKTREE_PRUNER_FLAG } from "../lib/lanes/outpost-worktree-pruner-flag.js";
+import { OUTPOST_WORKTREE_PRUNER_DEFAULT_MIN_AGE_DAYS, runOutpostWorktreePruner, } from "../lib/lanes/outpost-worktree-pruner.js";
+import { defaultOutpostPrunerSystemdDir, installOutpostPrunerTimers, uninstallOutpostPrunerTimers, } from "../lib/lanes/outpost-pruner-install.js";
+import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
+function errorType(error) {
+    return error instanceof Error ? error.name : "UnknownError";
+}
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+function printErrorJson(event, error, fields = {}) {
+    printJson({ event, ...fields, error: errorType(error) });
+}
+function runSystemctl(binary, args) {
+    const result = spawnSync(binary, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return {
+        status: result.status ?? 1,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+    };
+}
+function systemdRoot(option) {
+    return path.resolve(option ?? defaultOutpostPrunerSystemdDir(os.homedir()));
+}
+function skippedResult(trigger, minAgeDays, reason) {
+    return {
+        event: "outpost.worktree_pruner.run",
+        trigger,
+        dry_run: false,
+        feature_enabled: false,
+        skipped: reason,
+        flag: OUTPOST_WORKTREE_PRUNER_FLAG,
+        min_age_days: minAgeDays,
+        candidates: [],
+        removed: [],
+        kept: [],
+        bytes_freed: 0,
+        bytes_freed_basis: "statfs_available_byte_delta",
+        package_store: { attempted: false, reason: "not_run" },
+    };
+}
+export function registerOutpostPrunerCommand(lanes) {
+    const pruner = lanes
+        .command("outpost-pruner")
+        .description("Inspect, install, and run safe outpost worktree pruning");
+    pruner
+        .command("run")
+        .description("Run the guarded outpost worktree and user-cache cleanup")
+        .option("--trigger <kind>", "pressure | daily | manual", "manual")
+        .option("--min-age-days <days>", "Minimum age before cleanup (1–365 days)", (value) => Number(value), OUTPOST_WORKTREE_PRUNER_DEFAULT_MIN_AGE_DAYS)
+        .option("--dry-run", "List eligible worktrees without deleting files")
+        .action(async (options) => {
+        const trigger = options.trigger ?? "manual";
+        const minAgeDays = options.minAgeDays ?? OUTPOST_WORKTREE_PRUNER_DEFAULT_MIN_AGE_DAYS;
+        try {
+            if (!["pressure", "daily", "manual"].includes(trigger)) {
+                throw new TypeError("invalid trigger");
+            }
+            const featureEnabled = options.dryRun ? false : await outpostWorktreePrunerEnabled();
+            if (!options.dryRun && !featureEnabled) {
+                printJson(skippedResult(trigger, minAgeDays, "feature_flag_off"));
+                return;
+            }
+            const result = runOutpostWorktreePruner({
+                hqRoot: resolveLanesHqRoot(),
+                trigger,
+                dryRun: Boolean(options.dryRun),
+                featureEnabled,
+                minAgeDays,
+            });
+            printJson({ ...result, flag: OUTPOST_WORKTREE_PRUNER_FLAG });
+        }
+        catch (error) {
+            printErrorJson("outpost.worktree_pruner.run", error, {
+                trigger,
+                dry_run: Boolean(options.dryRun),
+            });
+            process.exitCode = 1;
+        }
+    });
+    pruner
+        .command("install")
+        .description("Write the pressure and daily systemd user timers")
+        .option("--systemd-root <path>", "Systemd user unit directory")
+        .option("--enable", "Enable both timers after writing the units")
+        .action((options) => {
+        try {
+            const result = installOutpostPrunerTimers({
+                systemdRoot: systemdRoot(options.systemdRoot),
+                hqRoot: resolveLanesHqRoot(),
+                home: os.homedir(),
+                enable: Boolean(options.enable),
+                runCommand: options.enable ? runSystemctl : undefined,
+            });
+            printJson(result);
+        }
+        catch (error) {
+            printErrorJson("outpost.worktree_pruner.install", error);
+            process.exitCode = 1;
+        }
+    });
+    pruner
+        .command("uninstall")
+        .description("Disable and remove the pressure and daily systemd user timers")
+        .option("--systemd-root <path>", "Systemd user unit directory")
+        .option("--disable", "Disable both timers before removing their units")
+        .action((options) => {
+        try {
+            const result = uninstallOutpostPrunerTimers({
+                systemdRoot: systemdRoot(options.systemdRoot),
+                disable: Boolean(options.disable),
+                runCommand: options.disable ? runSystemctl : undefined,
+            });
+            printJson(result);
+        }
+        catch (error) {
+            printErrorJson("outpost.worktree_pruner.uninstall", error);
+            process.exitCode = 1;
+        }
+    });
+}
+//# sourceMappingURL=outpost-pruner.js.map

package/dist/lib/daemon/catalog.d.ts

@@ -10,7 +10,7 @@
  * them instead of silently dropping them.
  */
 import type { MachineType } from "./machine-type.js";
-export declare const SERVICE_NAMES: readonly ["sync", "mesh", "heartbeat", "inbox", "bots", "remote-control", "session-host", "lanes-reconcile", "search-index", "jobs-reconcile", "updater", "housekeeping"];
+export declare const SERVICE_NAMES: readonly ["sync", "mesh", "heartbeat", "inbox", "bots", "remote-control", "codex-remote-control", "session-host", "lanes-reconcile", "search-index", "jobs-reconcile", "updater", "housekeeping"];
 export type ServiceName = (typeof SERVICE_NAMES)[number];
 export declare function isServiceName(value: unknown): value is ServiceName;
 export declare const SERVICE_DESCRIPTIONS: Record<ServiceName, string>;
@@ -79,7 +79,17 @@ export interface PlanContext {
     tmuxPath: string | null;
     /** Short host name, used to name this machine's remote-control session. */
     hostName: string;
+    /** The session name the box's own runner used (`--name` in its script), kept when the daemon takes over. */
+    remoteControlName: string | null;
+    /** Absolute path of the login user's codex binary, or null. */
+    codexPath: string | null;
+    /** The box's Codex remote-control runner script, when it has one. */
+    codexRunnerScript: string | null;
 }
+/** Written by outpost provisioning; the daemon runs it rather than re-implementing Codex login and relay setup. */
+export declare const CODEX_RUNNER_SCRIPT = "/usr/local/bin/outpost-codex-runner.sh";
+/** The outpost's Claude runner script, read for the session name it uses. */
+export declare const CLAUDE_RUNNER_SCRIPT = "/usr/local/bin/outpost-runner.sh";
 /** Turn enabled services into concrete units for this host. */
 export declare function planUnits(services: readonly ServiceName[], ctx: PlanContext): UnitPlan[];
 //# sourceMappingURL=catalog.d.ts.map

package/dist/lib/daemon/catalog.js

@@ -16,6 +16,7 @@ export const SERVICE_NAMES = [
     "inbox",
     "bots",
     "remote-control",
+    "codex-remote-control",
     "session-host",
     "lanes-reconcile",
     "search-index",
@@ -33,16 +34,17 @@ export const SERVICE_DESCRIPTIONS = {
     inbox: "picks up the agent's incoming messages and tasks",
     bots: "runs local bots",
     "remote-control": "keeps Claude remote control running",
+    "codex-remote-control": "keeps Codex remote control running",
     "session-host": "lets the desktop app open this machine's Claude sessions",
     "lanes-reconcile": "cleans up stalled background lanes",
     "search-index": "keeps local search up to date",
     "jobs-reconcile": "keeps scheduled jobs matched to the cloud",
-    updater: "keeps the hq CLI and Codex up to date",
+    updater: "keeps the hq CLI, Claude, Codex and Grok up to date",
     housekeeping: "rotates daemon logs",
 };
 /** The services each machine type runs without being asked. */
 export const DEFAULT_SERVICES = {
-    desktop: ["sync", "mesh", "heartbeat", "bots", "lanes-reconcile", "search-index", "housekeeping"],
+    desktop: ["sync", "mesh", "heartbeat", "bots", "lanes-reconcile", "search-index", "updater", "housekeeping"],
     "self-hosted": [
         "sync",
         "mesh",
@@ -59,6 +61,7 @@ export const DEFAULT_SERVICES = {
         "mesh",
         "heartbeat",
         "remote-control",
+        "codex-remote-control",
         "session-host",
         "lanes-reconcile",
         "search-index",
@@ -93,6 +96,10 @@ function firstBlock(checks) {
     const hit = checks.find(([blocked]) => blocked);
     return hit ? { state: "waiting", reason: hit[1] } : undefined;
 }
+/** Written by outpost provisioning; the daemon runs it rather than re-implementing Codex login and relay setup. */
+export const CODEX_RUNNER_SCRIPT = "/usr/local/bin/outpost-codex-runner.sh";
+/** The outpost's Claude runner script, read for the session name it uses. */
+export const CLAUDE_RUNNER_SCRIPT = "/usr/local/bin/outpost-runner.sh";
 const NO_HQ_ROOT = "no HQ folder configured (run `hq daemon install --hq-root <path>`)";
 const NOT_SIGNED_IN = "not signed in (run `hq login`)";
 const KIT_NOT_SET_UP = "the agent kit is not set up on this machine (run `hq agent kit install`)";
@@ -205,9 +212,6 @@ function planService(service, ctx) {
                     intervalSec: 6 * 3600,
                     initialDelaySec: 900,
                     command: { type: "hq", args: ["daemon", "service", "self-update"] },
-                    blocked: firstBlock([
-                        [!ctx.cliSelfUpdatable, "this hq CLI is not a global install, so it is updated with the project or app that owns it"],
-                    ]),
                 }),
             ];
         case "jobs-reconcile": {
@@ -232,12 +236,33 @@ function planService(service, ctx) {
                 }),
             ];
         }
+        case "codex-remote-control": {
+            if (ctx.platform === "win32")
+                return [unavailable(service, "not supported on Windows")];
+            const script = ctx.codexRunnerScript;
+            return [
+                base(service, {
+                    command: {
+                        type: "hq",
+                        args: ["daemon", "service", "codex-remote-control", "--script", script ?? "", "--codex", ctx.codexPath ?? ""],
+                    },
+                    env: ctx.hqRoot ? { HQ_ROOT: ctx.hqRoot } : {},
+                    blocked: firstBlock([
+                        [!script, `this machine has no Codex remote-control runner (${CODEX_RUNNER_SCRIPT})`],
+                        [!ctx.codexPath, "the codex CLI is not installed"],
+                        [!ctx.tmuxPath, "tmux is not installed (Codex remote control runs inside tmux)"],
+                        [!ctx.hqRoot, NO_HQ_ROOT],
+                    ]),
+                }),
+            ];
+        }
         case "remote-control": {
             if (ctx.platform === "win32")
                 return [unavailable(service, "not supported on Windows yet")];
             // Outposts keep the runner's session name and permission mode.
             const outpost = ctx.machineType === "outpost";
-            const args = ["daemon", "service", "remote-control", "--claude", ctx.claudePath ?? "", "--name", outpost ? "outpost-1" : ctx.hostName];
+            const name = ctx.remoteControlName ?? (outpost ? "outpost-1" : ctx.hostName);
+            const args = ["daemon", "service", "remote-control", "--claude", ctx.claudePath ?? "", "--name", name];
             if (outpost)
                 args.push("--permission-mode", "bypassPermissions");
             return [

package/dist/lib/daemon/install.d.ts

@@ -64,6 +64,13 @@ export interface DaemonUnitResult {
 export interface InstallDeps {
     run: RunCommand;
 }
+export declare const ROOT_REFUSAL = "hq daemon runs its services as the machine's login user, never as root.";
+/**
+ * Why the daemon must not run here as root, or null when it may. Agent kits
+ * are the one exception: they run in containers where root is often the only
+ * account.
+ */
+export declare function daemonRootRefusal(isRoot: boolean, machineType: MachineType): string | null;
 /** Boxes run the daemon as a system unit; everything else per user. */
 export declare function installScopeFor(machineType: MachineType): InstallScope;
 export declare function planDaemonUnit(host: DaemonHost, options: InstallOptions): DaemonUnitPlan;