@indigoai-us/hq-cli 5.147.0 → 5.149.1

package/dist/commands/mcp-registration.d.ts

@@ -74,6 +74,15 @@ export declare class ConfigParseError extends McpRegistrationError {
 export declare class ConfigPermissionError extends McpRegistrationError {
     readonly code: "ConfigPermissionError";
 }
+export type CodexMcpCollisionOwner = 'hq' | 'foreign' | 'unknown';
+export type CodexMcpCollisionField = 'command' | 'args' | 'env' | 'url' | 'other';
+/** Safe, value-free context for a Codex name collision reported to Sentry. */
+export interface CodexMcpCollisionDiagnostics {
+    client: 'codex';
+    serverName: string;
+    existingEntryOwner: CodexMcpCollisionOwner;
+    diffFields: CodexMcpCollisionField[];
+}
 /**
  * A server name is already present in the target config with a DIFFERENT
  * definition than the one being merged (def-equal = idempotent no-op;
@@ -82,6 +91,8 @@ export declare class ConfigPermissionError extends McpRegistrationError {
  */
 export declare class McpNameCollisionError extends McpRegistrationError {
     readonly code: "McpNameCollisionError";
+    readonly codexDiagnostics?: CodexMcpCollisionDiagnostics;
+    constructor(message: string, codexDiagnostics?: CodexMcpCollisionDiagnostics);
 }
 /**
  * The Codex runtime is absent (`~/.codex` missing). This is a FIRST-CLASS SKIP,
@@ -494,7 +505,8 @@ export declare function serverDefsEqual(a: unknown, b: unknown): boolean;
  *     it — but byte-equality of the rest means {@link writeConfigAtomic} writes
  *     nothing unless the stamp itself is the only delta, which we treat as a no-op
  *     by returning the original doc.
- *   - name PRESENT, def-DIFFERS -> {@link McpNameCollisionError} ABORT.
+ *   - name PRESENT, def-DIFFERS, same non-empty `_hqPack` -> replace the entry.
+ *   - name PRESENT, def-DIFFERS, unmarked or different owner -> collision ABORT.
  *
  * Never touches any OTHER server entry or any other top-level key.
  */
@@ -646,8 +658,8 @@ type TomlTable = Record<string, unknown>;
  * The Codex doc threaded through the safe-write core. We carry BOTH the parsed
  * value (`value`, for the merge fn + verify) AND the ORIGINAL file text
  * (`originalText`, `null` for a fresh/empty file). {@link codexConfigFormat.serialize}
- * uses `originalText` to APPEND the one new table without re-serializing — and so
- * without dropping — the user's existing comments and tables. This is the seam that
+ * uses `originalText` to APPEND a new table or replace sections of a same-pack
+ * owned table without re-serializing unrelated content. This is the seam that
  * makes "preserves comments" honest within a value-only TOML library.
  */
 export interface CodexTomlDoc {
@@ -661,7 +673,7 @@ export declare const CODEX_MCP_SERVERS_KEY = "mcp_servers";
 /**
  * Serialize EXACTLY ONE server table (`[mcp_servers.<name>]` + its sub-tables)
  * by wrapping the def under `mcp_servers.<name>` and round-tripping it through
- * smol-toml. Used both for the append path (preserve-comments) and for the
+ * smol-toml. Used for appending new servers, replacing an owned table, and the
  * collision/equality comparison. The output is deterministic for a given def so a
  * re-install produces byte-identical text (idempotency depends on it).
  */
@@ -670,15 +682,15 @@ export declare function serializeOneCodexServer(name: string, def: TomlTable): s
  * The Codex `ConfigFormat`. `parse` round-trips the file through smol-toml
  * (throwing `TomlError` on malformed NON-empty input → the substrate maps it to
  * {@link ConfigParseError}, FAIL-CLOSED). `serialize` is comment-preserving: when
- * the doc carries `originalText` (the file pre-existed) it APPENDS the new
- * `mcp_servers.<name>` table to the original bytes rather than re-serializing the
- * whole value; only when there is no original (`null`) does it serialize the full
- * value from scratch. `assertEntry` checks `mcp_servers.<name>` is present.
- *
- * Because `serialize` needs the merged value to know WHICH server to append, the
- * merge fn ({@link mergeCodexServer}) records the just-added server on the doc; the
- * append path reads it back. For an idempotent no-op (server already present,
- * def-equal) the merge returns the doc UNCHANGED with no pending append, so
+ * the doc carries `originalText` (the file pre-existed) it APPENDS a new server
+ * table or replaces only a same-pack owned table, rather than re-serializing the
+ * whole value. Only a fresh file (`null`) is serialized from scratch.
+ * `assertEntry` checks `mcp_servers.<name>` is present.
+ *
+ * Because `serialize` needs to know WHICH server to append or replace, the merge
+ * fn ({@link mergeCodexServer}) records the operation on the doc. For an
+ * idempotent no-op (server already present, def-equal) the merge returns the doc
+ * UNCHANGED, so
  * `serialize` reproduces the original text exactly (no write happens).
  */
 export declare const codexConfigFormat: ConfigFormat<CodexTomlDoc>;
@@ -716,9 +728,10 @@ export declare function buildCodexToolsTable(tools: McpManifest['tools']): TomlT
  *   - name PRESENT, def-equal (provenance-ignored) → NO-OP (idempotent re-install /
  *     PARTIAL self-heal): return the doc UNCHANGED with no pending append, so the
  *     original text round-trips byte-for-byte.
- *   - name PRESENT, def-DIFFERS → {@link McpNameCollisionError} ABORT (never mutate
- *     an existing table — which is also what keeps the comment-preserving append
- *     sound: we only ever ADD).
+ *   - name PRESENT, def-DIFFERS, same `_hqPack` owner → update that owned table
+ *     while preserving unrelated TOML bytes and comments.
+ *   - name PRESENT, def-DIFFERS, any other owner → {@link McpNameCollisionError}
+ *     ABORT with value-free diagnostics.
  *
  * Never touches any OTHER server table or any other top-level table.
  */

package/dist/commands/mcp-registration.js

@@ -99,6 +99,11 @@ export class ConfigPermissionError extends McpRegistrationError {
  */
 export class McpNameCollisionError extends McpRegistrationError {
     code = 'McpNameCollisionError';
+    codexDiagnostics;
+    constructor(message, codexDiagnostics) {
+        super(message);
+        this.codexDiagnostics = codexDiagnostics;
+    }
 }
 /**
  * The Codex runtime is absent (`~/.codex` missing). This is a FIRST-CLASS SKIP,
@@ -1009,7 +1014,8 @@ function canonicalJson(v) {
  *     it — but byte-equality of the rest means {@link writeConfigAtomic} writes
  *     nothing unless the stamp itself is the only delta, which we treat as a no-op
  *     by returning the original doc.
- *   - name PRESENT, def-DIFFERS -> {@link McpNameCollisionError} ABORT.
+ *   - name PRESENT, def-DIFFERS, same non-empty `_hqPack` -> replace the entry.
+ *   - name PRESENT, def-DIFFERS, unmarked or different owner -> collision ABORT.
  *
  * Never touches any OTHER server entry or any other top-level key.
  */
@@ -1023,6 +1029,12 @@ export function mergeClaudeServer(name, def) {
                 // (do not re-stamp) so a re-install is a true byte-for-byte no-op.
                 return doc;
             }
+            const existingPack = provenanceOf(existing);
+            const incomingPack = provenanceOf(def);
+            if (existingPack && existingPack === incomingPack) {
+                servers[name] = def;
+                return { ...doc, mcpServers: servers };
+            }
             throw new McpNameCollisionError(`MCP server "${name}" is already defined in ~/.claude.json with a different ` +
                 'definition — refusing to overwrite. Remove or rename the existing server, ' +
                 'or uninstall the conflicting pack, then re-install.');
@@ -1302,7 +1314,7 @@ export const CODEX_MCP_SERVERS_KEY = 'mcp_servers';
 /**
  * Serialize EXACTLY ONE server table (`[mcp_servers.<name>]` + its sub-tables)
  * by wrapping the def under `mcp_servers.<name>` and round-tripping it through
- * smol-toml. Used both for the append path (preserve-comments) and for the
+ * smol-toml. Used for appending new servers, replacing an owned table, and the
  * collision/equality comparison. The output is deterministic for a given def so a
  * re-install produces byte-identical text (idempotency depends on it).
  */
@@ -1313,15 +1325,15 @@ export function serializeOneCodexServer(name, def) {
  * The Codex `ConfigFormat`. `parse` round-trips the file through smol-toml
  * (throwing `TomlError` on malformed NON-empty input → the substrate maps it to
  * {@link ConfigParseError}, FAIL-CLOSED). `serialize` is comment-preserving: when
- * the doc carries `originalText` (the file pre-existed) it APPENDS the new
- * `mcp_servers.<name>` table to the original bytes rather than re-serializing the
- * whole value; only when there is no original (`null`) does it serialize the full
- * value from scratch. `assertEntry` checks `mcp_servers.<name>` is present.
+ * the doc carries `originalText` (the file pre-existed) it APPENDS a new server
+ * table or replaces only a same-pack owned table, rather than re-serializing the
+ * whole value. Only a fresh file (`null`) is serialized from scratch.
+ * `assertEntry` checks `mcp_servers.<name>` is present.
  *
- * Because `serialize` needs the merged value to know WHICH server to append, the
- * merge fn ({@link mergeCodexServer}) records the just-added server on the doc; the
- * append path reads it back. For an idempotent no-op (server already present,
- * def-equal) the merge returns the doc UNCHANGED with no pending append, so
+ * Because `serialize` needs to know WHICH server to append or replace, the merge
+ * fn ({@link mergeCodexServer}) records the operation on the doc. For an
+ * idempotent no-op (server already present, def-equal) the merge returns the doc
+ * UNCHANGED, so
  * `serialize` reproduces the original text exactly (no write happens).
  */
 export const codexConfigFormat = {
@@ -1332,7 +1344,16 @@ export const codexConfigFormat = {
         return { value, originalText: text };
     },
     serialize(doc) {
-        const pending = doc[PENDING_APPEND];
+        const pendingDoc = doc;
+        const pendingUpdate = pendingDoc[PENDING_UPDATE];
+        if (doc.originalText !== null && pendingUpdate) {
+            const updated = replaceCodexTable(doc.originalText, pendingUpdate.name, pendingUpdate.def);
+            if (updated === null) {
+                throw new McpNameCollisionError(codexCollisionMessage(pendingUpdate.name), pendingUpdate.diagnostics);
+            }
+            return updated;
+        }
+        const pending = pendingDoc[PENDING_APPEND];
         if (doc.originalText !== null && pending) {
             // APPEND path: keep the original bytes verbatim (comments + every existing
             // table/sub-table preserved), then append the one new server table.
@@ -1362,6 +1383,7 @@ export const codexConfigFormat = {
 };
 /** Symbol carrying the pending append on a {@link CodexTomlDoc} (merge → serialize). */
 const PENDING_APPEND = Symbol('hqPendingCodexAppend');
+const PENDING_UPDATE = Symbol('hqPendingCodexUpdate');
 /** Return a copy of `value` with `mcp_servers.<name> = def` set (used for fresh-file serialize). */
 function withServer(value, name, def) {
     const servers = { ...(value[CODEX_MCP_SERVERS_KEY] ?? {}) };
@@ -1384,6 +1406,171 @@ export function appendCodexTable(originalText, name, def) {
     const body = block.endsWith('\n') ? block : `${block}\n`;
     return `${trimmed}\n\n${body}`;
 }
+/** Return the decoded table path for a valid TOML table header, or null. */
+function codexTablePath(headerLine) {
+    try {
+        const value = parseToml(headerLine);
+        const matches = [];
+        const visit = (current, pathParts) => {
+            if (current === null || typeof current !== 'object')
+                return;
+            if (Array.isArray(current)) {
+                current.forEach((item, index) => visit(item, [...pathParts, String(index)]));
+                return;
+            }
+            const table = current;
+            const entries = Object.entries(table);
+            if (entries.length === 0) {
+                matches.push(pathParts);
+                return;
+            }
+            for (const [key, child] of entries) {
+                visit(child, [...pathParts, key]);
+            }
+        };
+        visit(value, []);
+        return matches.length === 1 ? matches[0] : null;
+    }
+    catch {
+        // The caller has already parsed the whole document. Ordinary values are
+        // not table headers.
+        return null;
+    }
+}
+/**
+ * Locate real table headers without mistaking bracket-like text in TOML values
+ * for a header. Parsing the preceding prefix ensures a candidate is not inside
+ * an unfinished multiline string or array; smol-toml decodes quoted key paths.
+ */
+function codexTomlSections(text) {
+    const headers = [];
+    let offset = 0;
+    for (const line of text.match(/[^\n]*(?:\n|$)/g) ?? []) {
+        if (line.length === 0)
+            continue;
+        const content = line.replace(/\r?\n$/, '');
+        if (content.trimStart().startsWith('[')) {
+            try {
+                parseToml(text.slice(0, offset));
+                const path = codexTablePath(content);
+                if (path)
+                    headers.push({ start: offset, path });
+            }
+            catch {
+                // The prefix is incomplete TOML, so this bracket is part of a value.
+            }
+        }
+        offset += line.length;
+    }
+    return headers.map((header, index) => {
+        const nextStart = headers[index + 1]?.start ?? text.length;
+        let end = nextStart;
+        const trailingLines = text.slice(header.start, nextStart).match(/[^\n]*(?:\n|$)/g) ?? [];
+        for (let lineIndex = trailingLines.length - 1; lineIndex >= 0; lineIndex -= 1) {
+            const content = trailingLines[lineIndex].replace(/\r?\n$/, '');
+            if (content.trim() === '' || content.trimStart().startsWith('#')) {
+                end -= trailingLines[lineIndex].length;
+            }
+            else {
+                break;
+            }
+        }
+        return { ...header, end };
+    });
+}
+/** Extract comment text outside TOML strings so updating an owned table drops no user notes. */
+function codexTomlComments(text) {
+    const comments = [];
+    let multiline = null;
+    let lineOffset = 0;
+    for (const lineWithEnding of text.match(/[^\n]*(?:\n|$)/g) ?? []) {
+        if (lineWithEnding.length === 0)
+            continue;
+        const line = lineWithEnding.replace(/\r?\n$/, '');
+        let quote = null;
+        let index = 0;
+        while (index < line.length) {
+            if (multiline) {
+                const delimiter = multiline === 'basic' ? '"""' : "'''";
+                if (multiline === 'basic' && line[index] === '\\') {
+                    index += 2;
+                }
+                else if (line.startsWith(delimiter, index)) {
+                    multiline = null;
+                    index += 3;
+                }
+                else {
+                    index += 1;
+                }
+                continue;
+            }
+            if (quote) {
+                const closing = quote === 'basic' ? '"' : "'";
+                if (quote === 'basic' && line[index] === '\\') {
+                    index += 2;
+                }
+                else if (line[index] === closing) {
+                    quote = null;
+                    index += 1;
+                }
+                else {
+                    index += 1;
+                }
+                continue;
+            }
+            if (line[index] === '#') {
+                comments.push({ offset: lineOffset + index, text: line.slice(index) });
+                break;
+            }
+            if (line.startsWith('"""', index)) {
+                multiline = 'basic';
+                index += 3;
+            }
+            else if (line.startsWith("'''", index)) {
+                multiline = 'literal';
+                index += 3;
+            }
+            else if (line[index] === '"') {
+                quote = 'basic';
+                index += 1;
+            }
+            else if (line[index] === "'") {
+                quote = 'literal';
+                index += 1;
+            }
+            else {
+                index += 1;
+            }
+        }
+        lineOffset += lineWithEnding.length;
+    }
+    return comments;
+}
+/** Replace all sections for one same-pack server while retaining unrelated bytes and comments. */
+function replaceCodexTable(originalText, name, def) {
+    const sections = codexTomlSections(originalText);
+    const target = sections.filter((section) => section.path[0] === CODEX_MCP_SERVERS_KEY && section.path[1] === name);
+    if (!target.some((section) => section.path.length === 2))
+        return null;
+    const newline = originalText.includes('\r\n') ? '\r\n' : '\n';
+    const comments = codexTomlComments(originalText)
+        .filter((comment) => target.some((section) => comment.offset >= section.start && comment.offset < section.end))
+        .map((comment) => comment.text);
+    let output = '';
+    let cursor = 0;
+    let inserted = false;
+    for (const section of target) {
+        output += originalText.slice(cursor, section.start);
+        if (!inserted) {
+            output += serializeOneCodexServer(name, def).replace(/\n/g, newline);
+            if (comments.length > 0)
+                output += comments.join(newline) + newline;
+            inserted = true;
+        }
+        cursor = section.end;
+    }
+    return inserted ? output + originalText.slice(cursor) : null;
+}
 /**
  * Build the Codex server table emitted as `[mcp_servers.<name>]`: pass the
  * transport fields through, resolve `${secret:}` in every argument/header/env value
@@ -1447,9 +1634,10 @@ export function buildCodexToolsTable(tools) {
  *   - name PRESENT, def-equal (provenance-ignored) → NO-OP (idempotent re-install /
  *     PARTIAL self-heal): return the doc UNCHANGED with no pending append, so the
  *     original text round-trips byte-for-byte.
- *   - name PRESENT, def-DIFFERS → {@link McpNameCollisionError} ABORT (never mutate
- *     an existing table — which is also what keeps the comment-preserving append
- *     sound: we only ever ADD).
+ *   - name PRESENT, def-DIFFERS, same `_hqPack` owner → update that owned table
+ *     while preserving unrelated TOML bytes and comments.
+ *   - name PRESENT, def-DIFFERS, any other owner → {@link McpNameCollisionError}
+ *     ABORT with value-free diagnostics.
  *
  * Never touches any OTHER server table or any other top-level table.
  */
@@ -1463,9 +1651,23 @@ export function mergeCodexServer(name, def) {
                 // so serialize reproduces the original text exactly.
                 return doc;
             }
-            throw new McpNameCollisionError(`MCP server "${name}" is already defined in ~/.codex/config.toml with a different ` +
-                'definition — refusing to overwrite. Remove or rename the existing server, ' +
-                'or uninstall the conflicting pack, then re-install.');
+            const diagnostics = codexCollisionDiagnostics(name, existing, def);
+            const existingPack = isTomlTable(existing)
+                ? existing[HQ_PACK_PROVENANCE_KEY]
+                : undefined;
+            if (doc.originalText !== null &&
+                isTomlTable(existing) &&
+                typeof existingPack === 'string' &&
+                existingPack.length > 0 &&
+                existingPack === def[HQ_PACK_PROVENANCE_KEY]) {
+                const next = {
+                    value: withServer(doc.value, name, def),
+                    originalText: doc.originalText,
+                    [PENDING_UPDATE]: { name, def, diagnostics },
+                };
+                return next;
+            }
+            throw new McpNameCollisionError(codexCollisionMessage(name), diagnostics);
         }
         // Insert into the value (for verify-after-write) AND record the pending append
         // (for comment-preserving serialize).
@@ -1478,6 +1680,41 @@ export function mergeCodexServer(name, def) {
         return next;
     };
 }
+function isTomlTable(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function codexCollisionMessage(name) {
+    return `MCP server "${name}" is already defined in ~/.codex/config.toml with a different ` +
+        'definition — refusing to overwrite. Remove or rename the existing server, ' +
+        'or uninstall the conflicting pack, then re-install.';
+}
+function codexCollisionDiagnostics(name, existing, incoming) {
+    const existingTable = isTomlTable(existing) ? existing : {};
+    const owner = typeof existingTable[HQ_PACK_PROVENANCE_KEY] === 'string' &&
+        existingTable[HQ_PACK_PROVENANCE_KEY].length > 0
+        ? 'hq'
+        : 'unknown';
+    const keys = new Set([...Object.keys(existingTable), ...Object.keys(incoming)]);
+    keys.delete(HQ_PACK_PROVENANCE_KEY);
+    const fields = new Set();
+    for (const key of keys) {
+        const existingHasKey = Object.prototype.hasOwnProperty.call(existingTable, key);
+        const incomingHasKey = Object.prototype.hasOwnProperty.call(incoming, key);
+        if (existingHasKey === incomingHasKey &&
+            canonicalJson(existingTable[key]) === canonicalJson(incoming[key])) {
+            continue;
+        }
+        fields.add(key === 'command' || key === 'args' || key === 'env' || key === 'url'
+            ? key
+            : 'other');
+    }
+    return {
+        client: 'codex',
+        serverName: name,
+        existingEntryOwner: owner,
+        diffFields: [...fields].sort(),
+    };
+}
 /**
  * Emit ONE server into the GLOBAL Codex surface (`~/.codex/config.toml`
  * `[mcp_servers.<name>]`) via {@link writeConfigAtomic}. A FIRST-CLASS SKIP when the

package/dist/commands/mesh.js

@@ -9,11 +9,12 @@ import { resolve as resolvePath } from "node:path";
 import * as os from "node:os";
 import { readFileSync } from "node:fs";
 import { findHqRoot } from "../utils/manifest.js";
+import { CLI_VERSION } from "../cli-version.js";
 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, ensureProjectBoard } from "../lib/mesh/project-board.js";
+import { closeSupersededProjectThread, ensureMissingBoardStories, ensureProjectBoard } 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";
@@ -34,7 +35,7 @@ import { generateUlid } from "../lib/mesh/live/ulid.js";
 import { readLegacyBacklog } from "../lib/mesh/live/emit-replay.js";
 import { resolveMeshEmitMode, writeMeshConfigMode, } from "../lib/mesh/live/daemon/mode.js";
 import { workMeshRoot } from "../lib/mesh/live/paths.js";
-import { buildInstallPaths, collectDaemonDoctor, daemonServiceStatus, findAncestorHqRoot, resolveInstallHqRoot, detectPlatform, formatDaemonDoctor, installDaemonService, readDaemonState, runMeshDaemon, uninstallDaemonService, daemonDir, } from "../lib/mesh/live/daemon/index.js";
+import { buildInstallPaths, collectDaemonDoctor, daemonServiceStatus, findAncestorHqRoot, resolveInstallHqRoot, detectPlatform, formatCliIdentityLines, formatDaemonDoctor, installDaemonIfStale, installDaemonService, readDaemonState, resolveAbsoluteNodeBinary, resolveRunningCliEntry, runMeshDaemon, uninstallDaemonService, daemonDir, } from "../lib/mesh/live/daemon/index.js";
 import { workContextRoot } from "../lib/work-context/paths.js";
 import { formatMigrateConfirmation, submitSessionMigration, } from "../lib/work-context/migrate.js";
 import { formatOrganizeList, prepareOrganizeDecision, settleOrganizeAskWithoutBind, submitOrganizeDecision, } from "../lib/work-context/organize.js";
@@ -575,6 +576,29 @@ async function runPrdSync(opts) {
         ...(bound?.projectId ? { project: bound.projectId } : {}),
         touchedPaths: [resolvePath(file)],
     };
+    if (bound?.companyUid && bound.projectId) {
+        try {
+            const source = parseProjectPlan(readFileSync(file, "utf8"), file);
+            await ensureMissingBoardStories({
+                token,
+                company: {
+                    companyUid: bound.companyUid,
+                    companySlug: bound.companySlug || bound.companyUid,
+                },
+                projectId: bound.projectId,
+                name: source.name || bound.projectId,
+                description: source.description ?? "",
+                stories: source.stories,
+                repos: source.repos ?? [],
+                requiredIds: plan.events.map((event) => event.taskId),
+            });
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            console.error(`work-mesh: prd-sync ensure failed; emitting anyway (${reason.slice(0, 160)})`);
+        }
+    }
+    const meshRoot = workMeshHomeRoot();
     const seqFirst = reserveSessionSeq(sessionId, plan.events.length);
     const events = plan.events.map((event, index) => buildMeshEmitEvent({
         eventId: generateUlid(Date.now() + index),
@@ -592,7 +616,7 @@ async function runPrdSync(opts) {
     }));
     const poster = createEmitPoster({ token, baseUrl: resolveVaultApiBase(process.env) });
     const emitted = await emitEvents({
-        workMeshRoot: workMeshHomeRoot(),
+        workMeshRoot: meshRoot,
         poster,
         newEvents: events,
     });
@@ -601,8 +625,15 @@ async function runPrdSync(opts) {
         for (const line of formatEmitRejectionLines(emitted.rejections))
             console.error(line);
     }
-    plan.commit();
-    if (plan.taskId) {
+    const blocked = new Set(emitted.rejections.map((row) => row.eventId));
+    for (const pending of readEmitRetry(meshRoot)) {
+        const id = typeof pending.eventId === "string" ? pending.eventId : "";
+        if (id)
+            blocked.add(id);
+    }
+    const advanced = events.flatMap((event) => (event.eventId && event.taskId && !blocked.has(event.eventId) ? [event.taskId] : []));
+    plan.commit(advanced);
+    if (plan.taskId && advanced.includes(plan.taskId)) {
         updateSessionState(sessionId, root, (current) => {
             if (!current)
                 return null;
@@ -639,6 +670,12 @@ async function runDoctor(opts) {
         fail("`hq mesh doctor --apply` (paced Board PUTs from local prd.json) is not in the CLI yet.\n" +
             "Omit --apply to warm the conversation cache (directory, inbox, pair DMs).");
     }
+    const identity = collectDaemonDoctor();
+    const identityLines = formatCliIdentityLines(identity);
+    if (!opts.json) {
+        for (const line of identityLines)
+            console.log(line);
+    }
     const token = await requireToken();
     const principalUid = await resolveMeshPrincipalUid(token, loadCachedTokens());
     if (!principalUid) {
@@ -647,7 +684,15 @@ async function runDoctor(opts) {
     const warmed = await warmMeshConversationCache(token, principalUid);
     const needsProject = listNeedsProjectSessions(workContextHomeRoot());
     if (opts.json) {
-        console.log(JSON.stringify({ ok: true, action: "doctor", ...warmed, needsProject }, null, 2));
+        console.log(JSON.stringify({
+            ok: true,
+            action: "doctor",
+            ...warmed,
+            needsProject,
+            cliMismatchLine: identity.cliMismatchLine ?? null,
+            hqOnPath: identity.hqOnPath,
+            multipleHqOnPath: identity.multipleHqOnPath,
+        }, null, 2));
         return;
     }
     console.log(`Work mesh cache warmed at ${warmed.cacheRoot}` +
@@ -1938,6 +1983,7 @@ export function registerMeshCommand(program) {
         .description("Install LaunchAgent (macOS), systemd user unit (Linux), or Scheduled Task (Windows)")
         .option("--system-user <user>", "Write a root-owned unit template for agent boxes (e.g. ec2-user)")
         .option("--hq-root <path>", "HQ root to record for the service (else HQ_ROOT, else the nearest HQ root above cwd)")
+        .option("--if-stale", "Reinstall and restart only when this CLI is newer than the daemon's recorded version")
         .option("--json", "Print machine-readable JSON")
         .action((opts) => wrap(() => runDaemonInstall(opts))());
     daemon
@@ -1971,13 +2017,38 @@ async function runDaemonInstall(opts) {
     // Verified root only: a repo's own .claude/ must never become the daemon's
     // HQ root (that path is persisted as trusted and used for attribution).
     const hqRoot = resolveInstallHqRoot({ explicit: opts.hqRoot });
+    const paths = buildInstallPaths({
+        systemUser: opts.systemUser,
+        hqRoot: hqRoot.root,
+        hqRootSource: hqRoot.source,
+        hqBinary: resolveRunningCliEntry(),
+        nodeBinary: resolveAbsoluteNodeBinary(),
+    });
+    if (opts.ifStale) {
+        const stale = installDaemonIfStale({
+            currentVersion: CLI_VERSION,
+            platform: detectPlatform(),
+            paths,
+            systemUser: opts.systemUser,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                action: stale.reinstalled ? "install" : "unchanged",
+                reinstalled: stale.reinstalled,
+                message: stale.message,
+                hqBinary: paths.hqBinary,
+                nodeBinary: paths.nodeBinary,
+                hqRoot: hqRoot.root,
+            }, null, 2));
+            return;
+        }
+        console.log(stale.message);
+        return;
+    }
     const result = installDaemonService({
         platform: detectPlatform(),
-        paths: buildInstallPaths({
-            systemUser: opts.systemUser,
-            hqRoot: hqRoot.root,
-            hqRootSource: hqRoot.source,
-        }),
+        paths,
         systemUser: opts.systemUser,
     });
     if (opts.json) {

package/dist/lib/lanes/index.d.ts

@@ -3,8 +3,9 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
-export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneEnvelope, LaneHost, LaneProvider, LaneRecord, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
+export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
+export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneEnvelope, LaneHost, LaneProvider, LaneRecord, LaneStory, LaneStoryStatus, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
+export { ACTIVE_LANE_STORY_STATUSES, activeLaneStories, laneStories, laneStory, storyKey, storyStatusForEnvelope, storyWarning, withCurrentStory, withLaneStories, } from "./stories.js";
 export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
 export type { ConfigLoadDeps, ConfigWriteDeps } from "./config.js";
 export { resolveLanesHqRoot } from "./hq-root.js";

package/dist/lib/lanes/index.js

@@ -3,7 +3,8 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
+export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
+export { ACTIVE_LANE_STORY_STATUSES, activeLaneStories, laneStories, laneStory, storyKey, storyStatusForEnvelope, storyWarning, withCurrentStory, withLaneStories, } from "./stories.js";
 export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
 export { resolveLanesHqRoot } from "./hq-root.js";
 export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";

package/dist/lib/lanes/mesh-events.d.ts

@@ -78,6 +78,14 @@ export interface CreateLaneMeshOptions {
     interactive?: boolean;
     /** Test seam. Defaults to the shared `requireToken`. */
     token?: () => Promise<string>;
+    /** Repair a missing project view before retrying a story status patch. */
+    repairProjectView?: (input: {
+        token: string;
+        company: LaneCompanyRef;
+        projectId: string;
+        storyId: string;
+        status: string;
+    }) => Promise<void>;
 }
 export declare function createLaneMesh(opts?: CreateLaneMeshOptions): LaneMesh;
 /** Resolve the explicit mesh attribution before falling back to the lane tenant. */