@indigoai-us/hq-cli 5.235.0 → 5.237.0

package/dist/lib/bot/config.d.ts

@@ -29,6 +29,8 @@ export declare function normalizeBotCompanies(values: readonly string[] | undefi
 export declare function effectiveBotKind(config: Pick<BotConfig, "kind" | "workerId">): BotKind;
 /** The companies a bot belongs to (empty for a personal bot: its owner's memberships apply). */
 export declare function effectiveBotCompanies(config: Pick<BotConfig, "kind" | "companies" | "workerId">): string[];
+/** Longest display name (Slack's own limit for a bot's display name). */
+export declare const BOT_DISPLAY_NAME_MAX_CHARS = 35;
 /** Longest `intro` (first-start hello DM) a bot may store. */
 export declare const BOT_INTRO_MAX_CHARS = 500;
 /** Longest `kickoff` (first-start model turn prompt) a bot may store. */
@@ -61,6 +63,11 @@ export declare function validateBotEffort(runtime: BotRuntimeId, value: string):
  * it cannot be a model id.
  */
 export declare function validateBotModel(value: string): string | undefined;
+/**
+ * Trim and check a display name: the human name people see in HQ (the DM list,
+ * the bot's own "You are …"). The handle (`name`) stays the CLI's key.
+ */
+export declare function validateBotDisplayName(text: string): string;
 /** Trim and bound the intro text; throws an expected error when unusable. */
 export declare function validateBotIntro(text: string): string;
 /** Trim and bound the kickoff prompt; throws an expected error when unusable. */
@@ -112,6 +119,11 @@ export interface BotConfig {
      * the synced tree (~/.hq/bots/<name>/memory).
      */
     memoryDir?: string;
+    /**
+     * The human name people see (e.g. "Maya"). Sent to HQ as the bot's name at
+     * create; `name` stays the handle every hq bot command uses. Unset = `name`.
+     */
+    displayName?: string;
     /**
      * Verbatim hello the bot DMs its owner when it first comes online (and on
      * `hq bot intro`). Unset = the default introduction.

package/dist/lib/bot/config.js

@@ -64,6 +64,8 @@ export function effectiveBotCompanies(config) {
     }
     return listed;
 }
+/** Longest display name (Slack's own limit for a bot's display name). */
+export const BOT_DISPLAY_NAME_MAX_CHARS = 35;
 /** Longest `intro` (first-start hello DM) a bot may store. */
 export const BOT_INTRO_MAX_CHARS = 500;
 /** Longest `kickoff` (first-start model turn prompt) a bot may store. */
@@ -120,6 +122,29 @@ export function validateBotModel(value) {
     }
     return v;
 }
+/**
+ * Trim and check a display name: the human name people see in HQ (the DM list,
+ * the bot's own "You are …"). The handle (`name`) stays the CLI's key.
+ */
+export function validateBotDisplayName(text) {
+    const trimmed = (text ?? "").replace(/\s+/g, " ").trim();
+    if (!trimmed) {
+        throw Object.assign(new Error("--display-name needs some text (the name people see, e.g. Maya)."), {
+            expected: true,
+        });
+    }
+    if (trimmed.length > BOT_DISPLAY_NAME_MAX_CHARS) {
+        throw Object.assign(new Error(`--display-name is too long (${trimmed.length} chars); keep it under ${BOT_DISPLAY_NAME_MAX_CHARS}.`), {
+            expected: true,
+        });
+    }
+    if (!/^[\p{L}\p{M}][\p{L}\p{M} .'-]*$/u.test(trimmed)) {
+        throw Object.assign(new Error("--display-name can use letters, spaces, apostrophes, periods and hyphens."), {
+            expected: true,
+        });
+    }
+    return trimmed;
+}
 /** Trim and bound the intro text; throws an expected error when unusable. */
 export function validateBotIntro(text) {
     const trimmed = (text ?? "").replace(/\r\n/g, "\n").trim();

package/dist/lib/bot/local-config.d.ts

@@ -34,13 +34,14 @@ export interface BotLocalConfig {
     autoApprove?: boolean;
     /** Only the memory *kind* travels — never an absolute path from another Mac. */
     memory?: BotMemoryMode;
+    displayName?: string;
     intro?: string;
     kickoff?: string;
 }
 /** Walks a value and throws when any key looks like it could carry a secret. */
 export declare function assertNoSecretKeys(value: unknown, path?: string): void;
 /** The bot.json fields a localConfig is built from — nothing else is read. */
-export type BotLocalConfigSource = Pick<BotConfig, "runtime" | "workerSource" | "workerId" | "companySlug" | "model" | "effort" | "kind" | "companies" | "autoApprove" | "memoryDir" | "intro" | "kickoff">;
+export type BotLocalConfigSource = Pick<BotConfig, "runtime" | "workerSource" | "workerId" | "companySlug" | "model" | "effort" | "kind" | "companies" | "autoApprove" | "memoryDir" | "displayName" | "intro" | "kickoff">;
 /**
  * The non-secret settings of a bot, for the cloud to keep. Absolute paths
  * (hqRoot, memoryDir, workerDir) are deliberately left out: they belong to the

package/dist/lib/bot/local-config.js

@@ -51,6 +51,7 @@ export function buildBotLocalConfig(config) {
         ...(kind === "company" ? { companies } : {}),
         ...(config.autoApprove === false ? { autoApprove: false } : {}),
         memory: botMemoryMode(config),
+        ...(config.displayName ? { displayName: config.displayName } : {}),
         ...(config.intro ? { intro: config.intro } : {}),
         ...(config.kickoff ? { kickoff: config.kickoff } : {}),
     };
@@ -107,6 +108,9 @@ export function parseBotLocalConfig(value) {
     const memory = str("memory");
     if (isBotMemoryMode(memory))
         out.memory = memory;
+    const displayName = str("displayName");
+    if (displayName)
+        out.displayName = displayName;
     const intro = str("intro");
     if (intro)
         out.intro = intro;

package/dist/lib/bot/progress.d.ts

@@ -27,6 +27,9 @@ export declare const PROGRESS_COALESCE_MS = 2000;
 export declare const PROGRESS_MIN_GAP_MS = 4000;
 export declare const WORKING_NOTICE_MS = 60000;
 export declare const WORKING_NOTICE_TEXT = "Working on it \u2014 I'll reply here when it's done.";
+/** The setup bot's heads-up, sent once when a turn runs past SETUP_WORKING_NOTICE_MS. */
+export declare const SETUP_WORKING_NOTICE_MS = 30000;
+export declare const SETUP_WORKING_NOTICE_TEXT = "This one takes a minute. I'll reply here as soon as it's done.";
 export interface ProgressPosterOptions {
     /** Post one message; resolve true when it was delivered. */
     send: (body: string) => Promise<boolean>;
@@ -49,6 +52,14 @@ export interface ProgressPosterOptions {
      * (when the turn is not silent); `abandon` posts nothing.
      */
     buffer?: boolean;
+    /**
+     * Never post a message the model wrote right before a tool call. Those are
+     * the model's notes to itself ("Now write the worker."), not replies: the
+     * runtime stream shows them as a text block followed by a tool_use. A
+     * message is held until the next event says which it was: a tool call drops
+     * it, anything else (another message, the end of the turn) keeps it.
+     */
+    dropPreToolMessages?: boolean;
 }
 /** Whitespace-insensitive form used to recognise repeated text. */
 export declare function normalizeForCompare(text: string): string;
@@ -65,6 +76,9 @@ export declare class ProgressPoster {
     private readonly workingNoticeMs;
     private readonly workingNoticeText;
     private readonly buffer;
+    private readonly dropPreTool;
+    /** dropPreToolMessages: messages waiting to learn whether a tool call follows. */
+    private candidates;
     private pending;
     /** In-between questions, held until the turn ends (see the header). */
     private heldQuestions;
@@ -77,11 +91,22 @@ export declare class ProgressPoster {
     private finished;
     private noticeSent;
     private delivered;
+    /**
+     * Posts handed to the send chain this turn, counted when queued rather than
+     * when delivered. The "(no reply)" fallback checks this: a post still in
+     * flight when the turn ends has not bumped `delivered` yet, and counting only
+     * deliveries posted the placeholder right after a real message.
+     */
+    private queued;
     constructor(opts: ProgressPosterOptions);
     /** Arm the one-time "working on it" note. Call when the turn starts. */
     start(): void;
     /** One finished assistant message from the model. */
     message(text: string): void;
+    /** The model called a tool: whatever it wrote just before was a note to itself. */
+    tool(): void;
+    private promoteCandidates;
+    private accept;
     /** Posts that actually reached the chat (progress, notice and final). */
     get postedCount(): number;
     /** True once any message from the model was said this turn (not counting the notice). */

package/dist/lib/bot/progress.js

@@ -27,6 +27,9 @@ export const PROGRESS_COALESCE_MS = 2_000;
 export const PROGRESS_MIN_GAP_MS = 4_000;
 export const WORKING_NOTICE_MS = 60_000;
 export const WORKING_NOTICE_TEXT = "Working on it — I'll reply here when it's done.";
+/** The setup bot's heads-up, sent once when a turn runs past SETUP_WORKING_NOTICE_MS. */
+export const SETUP_WORKING_NOTICE_MS = 30_000;
+export const SETUP_WORKING_NOTICE_TEXT = "This one takes a minute. I'll reply here as soon as it's done.";
 /** Whitespace-insensitive form used to recognise repeated text. */
 export function normalizeForCompare(text) {
     return text.replace(/\s+/g, "");
@@ -46,6 +49,9 @@ export class ProgressPoster {
     workingNoticeMs;
     workingNoticeText;
     buffer;
+    dropPreTool;
+    /** dropPreToolMessages: messages waiting to learn whether a tool call follows. */
+    candidates = [];
     pending = [];
     /** In-between questions, held until the turn ends (see the header). */
     heldQuestions = [];
@@ -58,6 +64,13 @@ export class ProgressPoster {
     finished = false;
     noticeSent = false;
     delivered = 0;
+    /**
+     * Posts handed to the send chain this turn, counted when queued rather than
+     * when delivered. The "(no reply)" fallback checks this: a post still in
+     * flight when the turn ends has not bumped `delivered` yet, and counting only
+     * deliveries posted the placeholder right after a real message.
+     */
+    queued = 0;
     constructor(opts) {
         this.send = opts.send;
         this.sendFinalFn = opts.sendFinal;
@@ -69,6 +82,7 @@ export class ProgressPoster {
         this.workingNoticeMs = opts.workingNoticeMs ?? WORKING_NOTICE_MS;
         this.workingNoticeText = opts.workingNoticeText ?? WORKING_NOTICE_TEXT;
         this.buffer = opts.buffer ?? false;
+        this.dropPreTool = opts.dropPreToolMessages ?? false;
     }
     /** Arm the one-time "working on it" note. Call when the turn starts. */
     start() {
@@ -93,6 +107,27 @@ export class ProgressPoster {
         // silence signal, not content, and must never be posted as progress.
         if (containsNoReplySentinel(t))
             return;
+        if (this.dropPreTool) {
+            // The previous message was not followed by a tool call: it was real.
+            this.promoteCandidates();
+            this.candidates.push(t);
+            return;
+        }
+        this.accept(t);
+    }
+    /** The model called a tool: whatever it wrote just before was a note to itself. */
+    tool() {
+        if (this.finished || !this.dropPreTool)
+            return;
+        this.candidates = [];
+    }
+    promoteCandidates() {
+        const kept = this.candidates;
+        this.candidates = [];
+        for (const t of kept)
+            this.accept(t);
+    }
+    accept(t) {
         this.cancelNotice();
         this.said.push(t);
         // An unmentioned room turn holds every in-between message: nothing is posted
@@ -124,6 +159,8 @@ export class ProgressPoster {
     async finish(finalText) {
         if (this.finished)
             return this.chain;
+        // A message the turn ended on (no tool after it) is real.
+        this.promoteCandidates();
         this.finished = true;
         this.cancelNotice();
         this.cancelFlush();
@@ -161,7 +198,7 @@ export class ProgressPoster {
         const shouldAddFinal = Boolean(final && !this.repeatsSaid(final));
         if (!shouldAddFinal && held.length > 0)
             this.pending.push(...held);
-        if (this.pending.length === 0 && this.delivered === 0 && !shouldAddFinal)
+        if (this.pending.length === 0 && this.queued === 0 && !shouldAddFinal)
             this.pending.push("(no reply)");
         if (this.sendFinalFn && shouldAddFinal) {
             // Flush any remaining progress messages first, then the final reply separately.
@@ -229,6 +266,7 @@ export class ProgressPoster {
         // path built this body.
         if (containsNoReplySentinel(body))
             return;
+        this.queued += 1;
         this.lastPostAt = this.now();
         this.chain = this.chain.then(async () => {
             try {

package/dist/lib/bot/prompt.d.ts

@@ -77,6 +77,8 @@ export declare function normalizeInstructions(raw: unknown): string | undefined;
 export declare function readPromptSources(hqRoot: string, workerDir: string, io?: PromptFs, opts?: ReadPromptSourcesOptions): PromptSources;
 export interface BuildSystemPromptInput {
     botName: string;
+    /** The human name people call the bot (e.g. "Maya"); unset = botName. */
+    displayName?: string;
     agentUid: string;
     ownerUid: string;
     hqRoot: string;

package/dist/lib/bot/prompt.js

@@ -229,6 +229,16 @@ export function readPromptSources(hqRoot, workerDir, io = defaultPromptFs, opts
     }
     return { workerYaml, persona: read("persona.md"), memory };
 }
+/**
+ * How the bot names itself: its display name when it has one ("Maya", with the
+ * handle kept for commands), else its handle.
+ */
+function introName(input) {
+    const display = input.displayName?.trim();
+    if (!display || display === input.botName)
+        return `"${input.botName}"`;
+    return `"${display}" (your hq bot handle is \`${input.botName}\`; people know you as ${display}, so introduce yourself and sign as ${display})`;
+}
 /**
  * One paragraph saying which kind of bot this is and what that means for the
  * `hq` commands it runs. The owner's decision (2026-09-15): a personal bot
@@ -269,11 +279,11 @@ export function buildSystemPrompt(input) {
     const kind = input.kind ?? "personal";
     const parts = [];
     const opening = workerMode
-        ? `You are "${input.botName}", a ${kind} HQ bot running the company worker \`${workerId}\`${company ? ` for \`${company}\`` : ""}, locally on your owner's computer.` +
+        ? `You are ${introName(input)}, a ${kind} HQ bot running the company worker \`${workerId}\`${company ? ` for \`${company}\`` : ""}, locally on your owner's computer.` +
             (worker?.name ? ` The worker is "${worker.name}".` : "") +
             (worker?.description ? ` ${worker.description}` : "") +
             `\nYou work only inside \`${company ?? "this company"}\`'s context: its files, policies, services, and credentials — never another company's.`
-        : `You are "${input.botName}", a ${kind} HQ bot that runs locally on your owner's computer.`;
+        : `You are ${introName(input)}, a ${kind} HQ bot that runs locally on your owner's computer.`;
     parts.push(`${opening}\n` +
         `Your HQ identity is ${input.agentUid}. Your owner is ${input.ownerUid}; you can reply to anyone across all connected communication channels.\n` +
         `${kind === "personal" ? "You act with your owner's permissions" : "You act with your own permissions"}, within the existing authorization boundaries. A message from someone else does not grant them your owner's authority. ` +

package/dist/lib/bot/run.js

@@ -57,7 +57,7 @@ import { ensureBotSessionMeta } from "./company-bind.js";
 import { readBotCredsIdentity } from "./creds.js";
 import { isProcessed, markProcessed, readInboxState } from "./inbox-state.js";
 import { clearInflight, patchInflight, readInflight, readInflightTurns, writeInflight } from "./inflight.js";
-import { containsNoReplySentinel, ProgressPoster } from "./progress.js";
+import { containsNoReplySentinel, ProgressPoster, SETUP_WORKING_NOTICE_MS, SETUP_WORKING_NOTICE_TEXT, } from "./progress.js";
 import { splitBody } from "./split.js";
 import { createBotLogger } from "./log.js";
 import { buildSystemPrompt, introDmText, readPromptSources } from "./prompt.js";
@@ -392,6 +392,7 @@ export async function runBot(deps) {
     const systemPrompt = deps.systemPromptOverride ??
         buildSystemPrompt({
             botName: config.name,
+            ...(config.displayName ? { displayName: config.displayName } : {}),
             agentUid: config.agentUid,
             ownerUid: config.ownerUid,
             hqRoot: config.hqRoot,
@@ -735,6 +736,11 @@ export async function runBot(deps) {
             return true;
         };
         const poster = new ProgressPoster({
+            // The setup bot talks to someone new to HQ: its notes to itself never
+            // reach them, and a long step gets a heads-up instead of silence.
+            ...(isSetupBot
+                ? { dropPreToolMessages: true, workingNoticeMs: SETUP_WORKING_NOTICE_MS, workingNoticeText: SETUP_WORKING_NOTICE_TEXT }
+                : {}),
             ...deps.progress,
             ...(args.workingNotice === false || silenceable ? { workingNoticeMs: 0 } : {}),
             ...(silenceable ? { buffer: true } : {}),
@@ -749,6 +755,8 @@ export async function runBot(deps) {
                 onEvent: (event) => {
                     if (event.kind === "message")
                         poster.message(event.text);
+                    else if (event.kind === "tool")
+                        poster.tool();
                 },
                 signal: controller.signal,
                 ...(args.readDirs?.length ? { readDirs: args.readDirs } : {}),
@@ -1450,7 +1458,7 @@ export async function runBot(deps) {
             tReceived,
             send,
             sendFinal,
-            workingNotice: !isSetupBot,
+            // The setup bot's own notice (SETUP_WORKING_NOTICE_TEXT) is set where the poster is built.
             silenceable: target.kind === "room" && !target.mentioned,
             ...(readDirs.length ? { readDirs } : {}),
             ...(target.kind === "room"

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

@@ -52,6 +52,9 @@ export declare function tryReadLane(hqRoot: string, laneId: string, deps?: Store
 export declare function readLane(hqRoot: string, laneId: string, deps?: StoreDeps): LaneRecord;
 export declare function tryReadQuestion(hqRoot: string, questionId: string, deps?: StoreDeps): QuestionRecord | null;
 export declare function readQuestion(hqRoot: string, questionId: string, deps?: StoreDeps): QuestionRecord;
+/** Semver precedence includes prerelease identifiers (for example, rc.2 > rc.1). */
+export declare function isLaneStoreVersionNewer(storedVersion: string, runningVersion: string): boolean;
+export declare const LANE_STORE_UPGRADE_COMMAND = "npm install -g @indigoai-us/hq-cli@latest";
 export declare function createLane(hqRoot: string, init: Omit<LaneRecord, "schema_version" | "lane_id" | "version" | "created_at" | "updated_at"> & Partial<Pick<LaneRecord, "schema_version" | "lane_id" | "version" | "created_at" | "updated_at">>, deps?: StoreDeps): LaneRecord;
 /** Hierarchy lock: separate from record writes so callers can CAS-write while holding it. */
 export declare function withLaneHireLocks<T>(hqRoot: string, laneIds: readonly string[], fn: () => T, deps?: StoreDeps): T;

package/dist/lib/lanes/store.js

@@ -10,6 +10,8 @@ import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import semver from "semver";
+import { CLI_VERSION } from "../../cli-version.js";
 import { generateUlid } from "../mesh/live/ulid.js";
 import { resolveLanesHqRoot } from "./hq-root.js";
 import { LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesError, isLaneVersionConflict, } from "./errors.js";
@@ -391,6 +393,26 @@ export function parseLaneRecord(raw, filePath) {
     const schema_version = requireString(raw.schema_version, "schema_version");
     parseMajorSchema(schema_version, "hq-lane", 1);
     requireString(raw.lane_id, "lane_id");
+    if (raw.written_by_version !== undefined) {
+        const writtenByVersion = requireString(raw.written_by_version, "written_by_version");
+        if (!semver.valid(writtenByVersion)) {
+            throw new LaneSchemaError("written_by_version must be a valid semver version", {
+                path: filePath,
+                field: "written_by_version",
+                value: writtenByVersion,
+            });
+        }
+    }
+    if (raw.owner_written_by_version !== undefined) {
+        const ownerWrittenByVersion = requireString(raw.owner_written_by_version, "owner_written_by_version");
+        if (!semver.valid(ownerWrittenByVersion)) {
+            throw new LaneSchemaError("owner_written_by_version must be a valid semver version", {
+                path: filePath,
+                field: "owner_written_by_version",
+                value: ownerWrittenByVersion,
+            });
+        }
+    }
     requireInt(raw.version, "version");
     requireInt(raw.depth, "depth");
     requireInt(raw.priority, "priority");
@@ -950,6 +972,52 @@ export function readQuestion(hqRoot, questionId, deps = defaultStoreDeps()) {
         throw new LaneNotFoundError("question", questionId);
     return record;
 }
+/** Semver precedence includes prerelease identifiers (for example, rc.2 > rc.1). */
+export function isLaneStoreVersionNewer(storedVersion, runningVersion) {
+    if (!semver.valid(storedVersion)) {
+        throw new LanesError("lane_store_version_invalid", "Lane store writer version is not valid semver", {
+            stored_version: storedVersion,
+        });
+    }
+    if (!semver.valid(runningVersion)) {
+        throw new LanesError("lane_store_version_invalid", "Running hq-cli version is not valid semver", {
+            running_version: runningVersion,
+        });
+    }
+    return semver.gt(storedVersion, runningVersion);
+}
+const OLDER_LANE_STORE_WRITE_OVERRIDE = "HQ_LANES_ALLOW_OLDER_WRITE";
+export const LANE_STORE_UPGRADE_COMMAND = "npm install -g @indigoai-us/hq-cli@latest";
+const warnedBackgroundWriterLaneIds = new Set();
+function assertLaneStoreWriteAllowed(lane, laneId, writer) {
+    const storedVersion = lane.written_by_version;
+    if (storedVersion === undefined || !isLaneStoreVersionNewer(storedVersion, CLI_VERSION))
+        return;
+    const warning = `Lane ${laneId} was last written by hq-cli ${storedVersion}, newer than running hq-cli ${CLI_VERSION}. Upgrade with \`${LANE_STORE_UPGRADE_COMMAND}\` before writing.`;
+    if (writer === "command" || writer === "creator") {
+        if (process.env[OLDER_LANE_STORE_WRITE_OVERRIDE] === "1") {
+            console.warn(`${warning} Proceeding because ${OLDER_LANE_STORE_WRITE_OVERRIDE}=1 was set for this command.`);
+            return;
+        }
+        throw new LanesError("lane_store_newer_cli", `${warning} For a one-command override, set ${OLDER_LANE_STORE_WRITE_OVERRIDE}=1.`, {
+            lane_id: laneId,
+            stored_version: storedVersion,
+            running_version: CLI_VERSION,
+            upgrade_command: LANE_STORE_UPGRADE_COMMAND,
+            override: `${OLDER_LANE_STORE_WRITE_OVERRIDE}=1`,
+        });
+    }
+    if (!warnedBackgroundWriterLaneIds.has(laneId)) {
+        warnedBackgroundWriterLaneIds.add(laneId);
+        console.warn(`${warning} Continuing background ${writer} writes and preserving the newer stamp.`);
+    }
+}
+function newestLaneStoreVersion(storedVersion) {
+    if (storedVersion !== undefined && isLaneStoreVersionNewer(storedVersion, CLI_VERSION)) {
+        return storedVersion;
+    }
+    return CLI_VERSION;
+}
 function recordsEquivalentAsideFromClock(current, updated) {
     if (updated === current)
         return true;
@@ -961,7 +1029,7 @@ function recordsEquivalentAsideFromClock(current, updated) {
     };
     return JSON.stringify(strip(current)) === JSON.stringify(strip(updated));
 }
-function casWrite(filePath, expectedVersion, parse, merge, updater, deps) {
+function casWrite(filePath, expectedVersion, parse, merge, updater, deps, options = {}) {
     return withRecordLock(filePath, deps, () => {
         const current = readMergedRecord(filePath, parse, merge, deps);
         if (current === null) {
@@ -980,9 +1048,11 @@ function casWrite(filePath, expectedVersion, parse, merge, updater, deps) {
         if (recordsEquivalentAsideFromClock(current, updated)) {
             return current;
         }
+        options.beforeWrite?.(current);
         const next = {
             ...current,
             ...updated,
+            ...options.stamp?.(current),
             version: current.version + 1,
             updated_at: deps.now().toISOString(),
         };
@@ -996,6 +1066,7 @@ export function createLane(hqRoot, init, deps = defaultStoreDeps()) {
     const filePath = laneRecordPath(hqRoot, lane_id);
     const record = {
         ...init,
+        written_by_version: CLI_VERSION,
         hire_grant: init.hire_grant ?? 0,
         schema_version: init.schema_version ?? LANE_SCHEMA_VERSION,
         lane_id,
@@ -1060,7 +1131,10 @@ export function updateLane(hqRoot, laneId, expectedVersion, writer, updater, dep
             }
         }
         return updated;
-    }, deps);
+    }, deps, {
+        beforeWrite: (current) => assertLaneStoreWriteAllowed(current, laneId, writer),
+        stamp: (current) => ({ written_by_version: newestLaneStoreVersion(current.written_by_version) }),
+    });
     if (laneStoryLedgerEnabled() && before && laneLedgerRelevantChange(before, updated)) {
         return syncStoryLedgerForLane(hqRoot, updated, deps);
     }
@@ -1182,7 +1256,12 @@ export function syncLaneRecordFromOwner(hqRoot, laneId, outpostId, rawOwnerLane,
             current.outpost_command_id !== undefined
             ? { ...ownerLane, outpost_command_id: current.outpost_command_id }
             : ownerLane;
-        const synced = mergeLaneRecords(ownerSnapshot, [current]);
+        const merged = mergeLaneRecords(ownerSnapshot, [current]);
+        const synced = {
+            ...merged,
+            written_by_version: newestLaneStoreVersion(current.written_by_version),
+            owner_written_by_version: ownerLane.written_by_version,
+        };
         parseLaneRecord(synced, filePath);
         atomicWriteJson(filePath, synced, deps);
         return synced;

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

@@ -318,6 +318,10 @@ export interface LaneStory {
 export interface LaneRecord {
     schema_version: typeof LANE_SCHEMA_VERSION | string;
     lane_id: string;
+    /** CLI release that most recently wrote this lane record. Absent on legacy rows. */
+    written_by_version?: string;
+    /** CLI release that most recently wrote the owner-host copy synced to primary. */
+    owner_written_by_version?: string;
     /** `null` is a core/personal lane (spec §6.2 / §10). Not an empty slug. */
     company: LaneCompanyRef | null;
     /** Explicit Work Mesh attribution for a personal lane; never inferred from cwd. */

package/dist/lib/lanes/types.js

@@ -216,7 +216,7 @@ export const REQUIRED_LANE_RECORD_FIELDS = [
 export const LANE_WRITERS = ["creator", "command", "watcher", "reconcile", "spawn", "story-ledger"];
 /** Field ownership at the durable-record mutation boundary (spec §10.1). */
 export const LANE_FIELD_WRITERS = {
-    schema_version: ["creator"], lane_id: ["creator"], company: ["creator"],
+    schema_version: ["creator"], lane_id: ["creator"], written_by_version: [], owner_written_by_version: [], company: ["creator"],
     project_id: ["command"], story_id: ["command"], no_story_reason: ["creator", "command"], ledger_sync_error: ["story-ledger"], pending_question_ids: ["story-ledger"], stories: ["creator", "command", "watcher", "reconcile", "spawn"], thread_id: ["creator", "command", "spawn"], mesh_company: ["creator", "command"],
     depth: ["command"], senior: ["command"], senior_history: ["command"],
     hire_grant: ["creator", "command"],

package/dist/node-network-compat.d.ts

@@ -1,28 +1,19 @@
 /**
  * Node network defaults for HQ CLI entry points.
  *
- * The compatibility timeout remains the default. On a canary where IPv6 is
- * advertised but unusable, the default-off hq-flags gate can also prefer IPv4
- * and disable automatic family racing before the CLI issues its first request.
+ * The compatibility timeout remains the default for HQ CLI entry points.
  *
  * Keep this module safe to import immediately after the Node version preflight.
- * The hq-flags reader loads dynamically so an unsupported runtime exits through
- * the preflight rather than failing during module linking.
  */
 export declare const HQ_NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS = 1000;
 export interface NodeNetworkCompatibilityOptions {
     nodeOptions?: string;
     execArgv?: readonly string[];
-    forceIpv4?: boolean;
     /**
      * Inject the net timeout setter (tests). Pass null to simulate a runtime
      * that lacks setDefaultAutoSelectFamilyAttemptTimeout.
      */
     setAttemptTimeout?: ((milliseconds: number) => void) | null;
-    /** Inject Node's automatic family selection setter (tests). */
-    setAutoSelectFamily?: ((enabled: boolean) => void) | null;
-    /** Inject Node's DNS result-order setter (tests). */
-    setDefaultResultOrder?: ((order: "ipv4first") => void) | null;
 }
 export declare function configureNodeNetworkCompatibility(options?: NodeNetworkCompatibilityOptions): boolean;
 //# sourceMappingURL=node-network-compat.d.ts.map