@indigoai-us/hq-cli 5.345.197 → 5.345.199

package/dist/lib/doctor/checks/bots.js

@@ -7,7 +7,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { botsRoot, botDir, launchdLabel } from "../../bot/paths.js";
-import { readBotConfig } from "../../bot/config.js";
+import { HQ_FLEET_RUNTIME_ENGINE_ID, readBotConfig } from "../../bot/config.js";
+import { checkClaudeCodeLogin, claudeLoginFix, describeClaudeLoginSources, } from "../../bot/claude-login.js";
 import { isPidAlive, readBotStatus } from "../../bot/status.js";
 import { nodeBinaryProblem } from "../../node-binary.js";
 import { launchdPlistProgramArguments, parseLaunchdCommand } from "../../service-manager/launchd.js";
@@ -17,6 +18,20 @@ const DEFAULT_DEPS = {
     home: () => os.homedir(),
     root: (home) => botsRoot(home ?? os.homedir()),
 };
+function isClaudeFleetBot(config) {
+    return config.engine?.id === HQ_FLEET_RUNTIME_ENGINE_ID && config.runtime === "claude";
+}
+/** The last reported failure, unless a later turn worked. */
+export function unresolvedLastFailure(status) {
+    const failure = status?.lastFailure;
+    if (!failure)
+        return null;
+    const failedAt = Date.parse(failure.at);
+    const okAt = status?.lastTurnOkAt ? Date.parse(status.lastTurnOkAt) : Number.NaN;
+    if (Number.isFinite(failedAt) && Number.isFinite(okAt) && okAt > failedAt)
+        return null;
+    return failure;
+}
 export const botsFamily = {
     id: BOTS_FAMILY_ID,
     title: BOTS_FAMILY_TITLE,
@@ -66,6 +81,7 @@ function runChecks(deps) {
         ];
     }
     const results = [];
+    let claudeLogin = null;
     for (const name of names) {
         const dir = botDir(name, root);
         const config = readBotConfig(dir);
@@ -73,6 +89,36 @@ function runChecks(deps) {
             continue;
         const status = readBotStatus(dir);
         const alive = !!status && status.state === "running" && isPidAlive(status.pid);
+        if (isClaudeFleetBot(config)) {
+            claudeLogin ??= (deps.claudeLogin ?? (() => checkClaudeCodeLogin({ home })))();
+            if (claudeLogin.signedIn) {
+                results.push({
+                    status: "PASS",
+                    checkId: `bots.${name}.claude-login`,
+                    target: dir,
+                    message: `${name} can read a Claude Code login here (${claudeLogin.via}).`,
+                });
+            }
+            else {
+                results.push({
+                    status: "FAIL",
+                    checkId: `bots.${name}.claude-login`,
+                    target: dir,
+                    message: `Claude Code is not signed in on this computer, so ${name} cannot answer. ${describeClaudeLoginSources(claudeLogin)}`,
+                    remediation: claudeLoginFix(name),
+                });
+            }
+        }
+        const lastFailure = unresolvedLastFailure(status);
+        if (lastFailure) {
+            results.push({
+                status: "FAIL",
+                checkId: `bots.${name}.last-failure`,
+                target: dir,
+                message: `${name} last failed at ${lastFailure.at} (${lastFailure.class}): ${lastFailure.cause}`,
+                remediation: `${lastFailure.fix} Details: hq bot status ${name}`,
+            });
+        }
         if (alive && status.lastHeartbeatOk === false) {
             const heartbeatMessage = status.lastHeartbeatReason === "identity_mismatch"
                 ? `${name} heartbeat stopped: identity mismatch (configured agent ${status.lastHeartbeatConfiguredAgentUid ?? config.agentUid}; token agent ${status.lastHeartbeatTokenAgentUid ?? "unknown"}).`

package/dist/lib/hot-channels/adapters/meetings.d.ts

@@ -42,6 +42,7 @@
  * watermark; the vault and other providers still land.
  */
 import { type PollHotChannelAdapter } from "../contract.js";
+export { meetingSignalSourceRef } from "../meeting-source-ref.js";
 export declare const MEETINGS_ADAPTER_ID = "meetings";
 export declare const MEETINGS_CHANNEL = "meeting-events";
 export declare const MEETINGS_PROVIDER = "hq-vault";

package/dist/lib/hot-channels/adapters/meetings.js

@@ -49,6 +49,8 @@ import { isAuthError } from "../../../utils/auth-error.js";
 import { MAX_CATCH_UP_WINDOW_MS } from "../contract.js";
 import { assertSafeSegment, HOT_SIGNAL_ORIGIN, writeFileAtomic } from "../landing.js";
 import { SyncLockLostError } from "../sync-lock.js";
+import { meetingSignalSourceRef } from "../meeting-source-ref.js";
+export { meetingSignalSourceRef } from "../meeting-source-ref.js";
 import { MEETING_NOTE_PROVIDERS, MEETING_PROVIDERS, sameMeeting, } from "./meeting-providers.js";
 export const MEETINGS_ADAPTER_ID = "meetings";
 export const MEETINGS_CHANNEL = "meeting-events";
@@ -217,7 +219,7 @@ function toEvent(t) {
         title: t.title,
         body,
         payloadRef,
-        frontmatter: { audience_source: t.audienceSource, provider: MEETINGS_VAULT_SOURCE },
+        frontmatter: { audience_source: t.audienceSource, provider: MEETINGS_VAULT_SOURCE, signal_source_ref: meetingSignalSourceRef(nonEmptyString(t.frontmatter.recall_bot_id) ?? t.transcriptId) },
         raw: { transcript: payloadRef, frontmatter: t.frontmatter, audience: [...t.audience], audience_source: t.audienceSource },
     };
 }

package/dist/lib/hot-channels/meeting-source-ref.d.ts

@@ -0,0 +1,3 @@
+/** Independent of transcript revisions and the adapter's versioned pointer filename. */
+export declare function meetingSignalSourceRef(id: string): string;
+//# sourceMappingURL=meeting-source-ref.d.ts.map

package/dist/lib/hot-channels/meeting-source-ref.js

@@ -0,0 +1,7 @@
+import { assertSafeSegment } from "./landing.js";
+/** Independent of transcript revisions and the adapter's versioned pointer filename. */
+export function meetingSignalSourceRef(id) {
+    assertSafeSegment(id, "meeting id");
+    return `meeting:${id}`;
+}
+//# sourceMappingURL=meeting-source-ref.js.map

package/dist/lib/hot-channels/schedule.js

@@ -76,9 +76,9 @@ export function toJobView(found, now) {
     return {
         botName: found.botName,
         jobId: found.job.jobId,
-        cron: found.job.cron,
+        cron: found.job.cron ?? "",
         timezone: found.job.timezone,
-        dailyAt: dailyAtOf(found.job.cron),
+        dailyAt: dailyAtOf(found.job.cron ?? ""),
         nextRunAt: next ? next.toISOString() : null,
         lastRunAt: found.job.lastRunAt ?? null,
     };

package/dist/lib/hot-channels/signals-pass.d.ts

@@ -1,35 +1,3 @@
-/**
- * The local signals pass (US-011). After each hot-channel adapter run, the
- * pass takes the adapter's channel through the ontology worklist, asks
- * `claude -p` for signals one document at a time, and writes those signals to
- * `companies/{co}/signals/`. It returns the count for the run ledger.
- *
- * Work comes from the worklist, not only from this run's landings: when the
- * worklist script exits 0, the pass takes the channel's unprocessed items in
- * the worklist's order (newest first) up to the run's document cap. Items the
- * cap leaves over stay unmarked, and a later run picks them up, including a
- * run that landed nothing (a bounded backlog drain: at most
- * DEFAULT_MAX_SIGNAL_DOCS claude calls per run, and no claude call at all when
- * the backlog is empty). A channel with no source.yaml (worklist exit 2, the
- * usual case for a hot channel such as `meeting-events`) has no worklist, so
- * the pass keeps its own backlog: landed documents it has not processed yet
- * are listed in `sources/_signals-pending/{channel}.json` and drained, newest
- * first by `when` (else `created_at`), on later runs under the same cap. A
- * cloud-run source (exit 4) is skipped.
- *
- * A landed document with both `payload_ref` and `raw_ref` is a pointer (the
- * meetings, Slack and Attio adapters land these). For it, claude gets the
- * pointer followed by the document `payload_ref` names, capped at
- * MAX_PAYLOAD_BYTES. A payload outside `sources/`, missing or unreadable falls
- * back to the pointer alone, and the reason is warned and kept on the signal.
- *
- * Billing: policy hq-no-headless-print-subscription-billing forbids headless
- * `claude -p` in general. This is its allowed case, per the owner decision of
- * 2026-10-21: the owner's own `claude` login, on their own machine, in a
- * bounded single-turn call. Cloud Claude is not the bot brain, and no model is
- * called from the poller itself. Do not reuse this pass for a shared, fleet or
- * hosted identity.
- */
 import type { HotChannelRunResult, WriteGuard } from "./loop.js";
 /** Ledger `error` values a failed pass records. */
 export type SignalsPassErrorCode = "claude-logged-out" | "claude-timeout" | "claude-bad-output";
@@ -128,6 +96,14 @@ interface ParsedSignal {
     type: SignalType;
     title: string;
     body: string;
+    update?: string;
+}
+export interface IndexRow {
+    signal_id: string;
+    type: string;
+    source_ref: string;
+    key: string;
+    written_at: string;
 }
 export declare function defaultPromptFile(): string;
 export declare const CLAUDE_LOGGED_OUT_RE: RegExp;
@@ -172,6 +148,7 @@ export declare function signalId(sourceRef: string, type: string, title: string)
 export declare function signalTypeDir(key: string, type: SignalType): string;
 /** Write `signals/@{key}/_audience.yaml` once, when the partition is first created. */
 export declare function ensureAudienceFile(vaultRoot: string, item: Pick<WorkItem, "audienceKey" | "principals" | "audienceSource">): Promise<void>;
+export declare function appendSignalIndex(vaultRoot: string, day: string, rows: readonly IndexRow[]): Promise<void>;
 /**
  * Build the claude signals pass for one company. The pass keeps state for one
  * run: the auth preflight runs once, and the document cap counts across every

package/dist/lib/hot-channels/signals-pass.js

@@ -1,3 +1,4 @@
+import { prepareSignalPublication, flushSignalPublications } from "../bot/jobs/signal-to-lane.js";
 /**
  * The local signals pass (US-011). After each hot-channel adapter run, the
  * pass takes the adapter's channel through the ontology worklist, asks
@@ -30,6 +31,7 @@
  * called from the poller itself. Do not reuse this pass for a shared, fleet or
  * hosted identity.
  */
+import { acquireSyncLock } from "./sync-lock.js";
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import * as fs from "node:fs/promises";
@@ -390,7 +392,10 @@ export function parseClaudeSignals(stdout) {
             typeof s.body !== "string") {
             throw new SignalsPassError("claude-bad-output", `claude signal ${i} has the wrong shape`);
         }
-        return { type: s.type, title: s.title.trim(), body: s.body.trim() };
+        if (s.update !== undefined && (typeof s.update !== "string" || !/^[a-f0-9]{64}$/.test(s.update))) {
+            throw new SignalsPassError("claude-bad-output", `claude signal ${i} has an invalid update id`);
+        }
+        return { type: s.type, title: s.title.trim(), body: s.body.trim(), ...(s.update ? { update: s.update } : {}) };
     });
 }
 /** `sha256(source_ref \n type \n title)`: the same signal from the same source keeps its id. */
@@ -441,25 +446,40 @@ export async function ensureAudienceFile(vaultRoot, item) {
             throw err;
     }
 }
-async function appendSignalIndex(vaultRoot, day, rows) {
+export async function appendSignalIndex(vaultRoot, day, rows) {
     if (rows.length === 0)
         return;
-    const file = path.join(vaultRoot, "signals", "_index", `${day}.json`);
-    let existing = [];
+    assertSafeSegment(day, "index day");
+    let lock = await acquireSyncLock(vaultRoot, `signal-index-${day}`);
+    for (let attempt = 0; !lock && attempt < 100; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        lock = await acquireSyncLock(vaultRoot, `signal-index-${day}`);
+    }
+    if (!lock)
+        throw new Error("Signal index is busy; retry this extraction");
     try {
-        const parsed = JSON.parse(await fs.readFile(file, "utf8"));
-        if (Array.isArray(parsed))
+        const file = path.join(vaultRoot, "signals", "_index", `${day}.json`);
+        let existing = [];
+        try {
+            const parsed = JSON.parse(await fs.readFile(file, "utf8"));
+            if (!Array.isArray(parsed))
+                throw new Error("Invalid daily signal index");
             existing = parsed;
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        const seen = new Set(existing.map((row) => row.signal_id));
+        const added = rows.filter((row) => !seen.has(row.signal_id));
+        if (added.length === 0)
+            return;
+        await lock.assertHeld();
+        await writeFileAtomic(vaultRoot, file, `${JSON.stringify([...existing, ...added], null, 2)}\n`);
     }
-    catch (err) {
-        if (err.code !== "ENOENT")
-            throw err;
+    finally {
+        await lock.release();
     }
-    const seen = new Set(existing.map((row) => row.signal_id));
-    const added = rows.filter((row) => !seen.has(row.signal_id));
-    if (added.length === 0)
-        return;
-    await writeFileAtomic(vaultRoot, file, `${JSON.stringify([...existing, ...added], null, 2)}\n`);
 }
 /**
  * Build the claude signals pass for one company. The pass keeps state for one
@@ -610,17 +630,20 @@ export function createClaudeSignalsPass(options) {
             await beforeWrite();
             await ensureAudienceFile(vaultRoot, item);
         }
+        const pointer = splitFrontmatter(await fs.readFile(path.join(vaultRoot, item.file), "utf8")).frontmatter;
+        const sourceRef = typeof pointer.signal_source_ref === "string" && /^meeting:[a-zA-Z0-9._-]+$/.test(pointer.signal_source_ref)
+            ? pointer.signal_source_ref : item.file;
         for (const signal of signals) {
-            const id = signalId(item.file, signal.type, signal.title);
+            const id = signalId(sourceRef, signal.type, signal.title);
             const key = `${signalTypeDir(item.audienceKey, signal.type)}/${id}.md`;
-            rows.push({ signal_id: id, type: signal.type, source_ref: item.file, key, written_at: at });
+            rows.push({ signal_id: id, type: signal.type, source_ref: sourceRef, key, written_at: at });
             const file = path.join(vaultRoot, key);
             if (await exists(file))
                 continue;
             const frontmatter = {
                 signal_id: id,
                 type: signal.type,
-                source_ref: item.file,
+                source_ref: sourceRef,
                 canonical_content: signal.title,
                 audience_key: item.audienceKey,
                 origin: SIGNAL_ORIGIN,
@@ -632,15 +655,26 @@ export function createClaudeSignalsPass(options) {
                 frontmatter.payload_fallback = input.fallback;
             const text = `---\n${yaml.dump(frontmatter, { lineWidth: -1, noRefs: true }).trimEnd()}\n---\n## ${heading(signal.type)}\n\n${signal.body || signal.title}\n`;
             await beforeWrite();
+            // Cloud-extracted signals arriving by upload/garden are out of scope.
+            prepareSignalPublication(options.hqRoot, options.company, {
+                signal_id: id, type: signal.type, source_ref: sourceRef,
+                audience_key: item.audienceKey, origin: SIGNAL_ORIGIN,
+            });
             await writeFileAtomic(vaultRoot, file, text);
+            // Publish the index before the event consumer looks up this new signal.
+            await appendSignalIndex(vaultRoot, at.slice(0, 10), [rows[rows.length - 1]]);
+            flushSignalPublications(options.hqRoot, options.company);
             written += 1;
         }
         await beforeWrite();
         await appendSignalIndex(vaultRoot, at.slice(0, 10), rows);
+        flushSignalPublications(options.hqRoot, options.company);
         return written;
     };
     return async (result, guard) => {
         const beforeWrite = guard?.beforeWrite ?? (async () => undefined);
+        await beforeWrite();
+        flushSignalPublications(options.hqRoot, options.company);
         const byChannel = new Map();
         // The adapter's own channel is listed even when this run landed nothing
         // there, so items an earlier run left over the cap still get processed.

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

@@ -10,6 +10,8 @@ export interface AdmissionHost {
 }
 export type AdmissionCapReason = "provider_cap" | "account_cap" | "profile_cap";
 export declare const ADMISSION_LOCK_STALE_MS = 30000;
+/** Serialize signal lookup and persistence separately from provider admission. */
+export declare function withSignalCreationLock<T>(hqRoot: string, key: string, fn: () => Promise<T>): Promise<T>;
 export declare function withLaneAdmissionLock<T>(hqRoot: string, provider: LaneRecord["provider"], fn: () => Promise<T>, sleep?: (ms: number) => Promise<void>): Promise<T>;
 export declare function withAllLaneAdmissionLocks<T>(hqRoot: string, fn: () => Promise<T>, sleep?: (ms: number) => Promise<void>): Promise<T>;
 export declare function laneRunsOnHost(lane: LaneRecord, host: AdmissionHost): boolean;

package/dist/lib/lanes/admission.js

@@ -88,6 +88,10 @@ async function withAdmissionLock(lockPath, fn, sleep) {
         }
     }
 }
+/** Serialize signal lookup and persistence separately from provider admission. */
+export function withSignalCreationLock(hqRoot, key, fn) {
+    return withAdmissionLock(path.join(hqRoot, "workspace", "lanes-runs", ".signal-locks", key + ".lock"), fn, defaultAdmissionSleep);
+}
 export function withLaneAdmissionLock(hqRoot, provider, fn, sleep = defaultAdmissionSleep) {
     return withAdmissionLock(admissionLockPath(hqRoot, provider), fn, sleep);
 }

package/dist/lib/lanes/approval-gate.js

@@ -73,9 +73,12 @@ export function enforceRegistryApprovalGate(lane, envelope) {
     if (missing.length === 0) {
         return { envelope, approvedIdsToConsume: used, violation: false };
     }
+    // The worker's outcome block described the action the gate just refused,
+    // so it does not carry over onto the blocked envelope.
+    const { outcome: _refusedOutcome, ...envelopeWithoutOutcome } = envelope;
     return {
         envelope: {
-            ...envelope,
+            ...envelopeWithoutOutcome,
             decision: "blocked",
             summary: `External action requires senior approval at checkpoint: ${missing.join(", ")}.`,
             story_status: "review",

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

@@ -30,10 +30,17 @@ export interface LinkResult {
     exitCode?: number;
 }
 export declare function resolveLinkSessionId(root: string, explicit: string | undefined, env?: NodeJS.ProcessEnv): string;
+/** Resolve only the caller's link, never another arbitrary open conductor. */
+export declare function resolveSignalConductor(root: string, env: NodeJS.ProcessEnv, explicitLink?: string, senior?: string): {
+    senior: string;
+    link?: string;
+};
 /** Cheap hook guard used before remote flag lookup or queue access. */
 export declare function linkedSessionIdFromHookInput(input: string): string;
-export declare function isLinkedSession(root: string, sid: string): boolean;
+export declare function isLinkedSession(root: string, sid: string, env?: NodeJS.ProcessEnv): boolean;
 export declare function drainLinkQueue(inbox: string): string;
+/** Called by the installed lane drain hook before core's pointer-file guard. */
+export declare function bindSignalLaneHook(root: string, input: string, env: NodeJS.ProcessEnv): void;
 export declare function runLaneLink(subcommand: string, options: LinkOptions): Promise<LinkResult>;
 /** Apply the default-on feature gate contract at the command boundary. */
 export declare function runLaneLinkWithFlag(subcommand: string, options: LinkOptions, enabled: boolean): Promise<LinkResult>;

package/dist/lib/lanes/links.js

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { appendDropboxMessageAtPath } from "./dropbox.js";
-import { withLaneRecordFileLock } from "./store.js";
+import { readLane, withLaneRecordFileLock } from "./store.js";
 import { LanesError } from "./errors.js";
 export const LANE_SESSION_LINKS_FLAG = "lanes.session-links";
 const ID_PATTERN = /^[A-Za-z0-9._-]+$/;
@@ -58,6 +58,33 @@ function readPointer(root, sid) {
         throw error;
     }
 }
+/** Resolve only the caller's link, never another arbitrary open conductor. */
+export function resolveSignalConductor(root, env, explicitLink, senior) {
+    if (senior === "user" && explicitLink === undefined)
+        return { senior: "user" };
+    let link = explicitLink;
+    if (link === undefined) {
+        try {
+            link = readPointer(root, resolveLinkSessionId(root, undefined, env))?.link;
+        }
+        catch { /* A missing caller pointer is handled below. */ }
+    }
+    try {
+        const dir = linkPath(root, link);
+        const meta = readJson(path.join(dir, "meta.json"));
+        if (typeof meta.conductor_session !== "string" || !safeId(meta.conductor_session))
+            throw new Error("invalid conductor");
+        const resolved = `session:${meta.conductor_session}`;
+        if (senior !== undefined && senior !== resolved)
+            throw new LanesError("signal_senior_mismatch", "Signal lane senior must match its conductor link");
+        return { senior: resolved, link };
+    }
+    catch (error) {
+        if (error instanceof LanesError)
+            throw error;
+        throw new LanesError("no_conductor_link", "No open conductor link for this session; pass --link or --senior user");
+    }
+}
 function atomicJson(file, value) {
     fs.mkdirSync(path.dirname(file), { recursive: true });
     const tmp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
@@ -95,7 +122,44 @@ export function linkedSessionIdFromHookInput(input) {
         return "";
     }
 }
-export function isLinkedSession(root, sid) {
+/** A fresh provider session is unknown until its first hook. Bind that session
+ * from the persisted lane, rather than inheriting the creator's pointer. */
+function bindSignalLaneSession(root, sid, env) {
+    if (!env.HQ_LANE_SIGNAL_LINK)
+        return;
+    const laneId = env.HQ_LANE_ID;
+    if (!safeId(sid) || !safeId(laneId) || readPointer(root, sid))
+        return;
+    let lane;
+    try {
+        lane = readLane(root, laneId);
+    }
+    catch {
+        process.stderr.write("hq lanes signal link: lane record unavailable\n");
+        return;
+    }
+    if (!lane.signal || !lane.signal_link || lane.signal_link !== env.HQ_LANE_SIGNAL_LINK)
+        return;
+    const dir = linkPath(root, lane.signal_link);
+    const meta = readJson(path.join(dir, "meta.json"));
+    if (lane.senior.kind !== "session" || lane.senior.id !== meta.conductor_session || sid === meta.conductor_session)
+        return;
+    const child = lane.lane_id;
+    const at = new Date().toISOString();
+    const childDir = path.join(dir, "children", child);
+    fs.mkdirSync(path.join(childDir, "inbox", "pending"), { recursive: true });
+    atomicJson(path.join(childDir, "meta.json"), { name: child, session_id: sid, engine: lane.provider, company: lane.company?.slug ?? "", title: lane.signal.title, state: "working", joined: at, updated: at });
+    fs.mkdirSync(path.dirname(pointerPath(root, sid)), { recursive: true });
+    fs.writeFileSync(pointerPath(root, sid), `child ${lane.signal_link} ${child}\n`, { flag: "wx", mode: 0o600 });
+}
+export function isLinkedSession(root, sid, env = process.env) {
+    try {
+        bindSignalLaneSession(root, sid, env);
+    }
+    catch {
+        process.stderr.write("hq lanes signal link: could not bind worker session\n");
+        return false;
+    }
     return Boolean(safeId(sid) && readPointer(root, sid));
 }
 function activeChild(root, link, name) {
@@ -478,6 +542,18 @@ function isChildHookPayload(payload) {
     const transcript = payload.transcript_path ?? payload.transcriptPath;
     return typeof transcript === "string" && /[/\\]subagents[/\\][^/\\]+\.jsonl$/.test(transcript);
 }
+/** Called by the installed lane drain hook before core's pointer-file guard. */
+export function bindSignalLaneHook(root, input, env) {
+    const payload = JSON.parse(input);
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return;
+    const record = payload;
+    if (isChildHookPayload(record))
+        return;
+    const sid = linkedSessionIdFromHookInput(input);
+    if (sid)
+        bindSignalLaneSession(root, sid, env);
+}
 export async function runLaneLink(subcommand, options) {
     const now = options.now ?? (() => new Date());
     const env = options.env ?? process.env;
@@ -498,13 +574,18 @@ export async function runLaneLink(subcommand, options) {
         childContext = isChildHookPayload(payload);
         stopHookActive = payload.stop_hook_active === true || payload.stopHookActive === true;
     }
-    const requireSid = () => sid || (sid = resolveLinkSessionId(root, options.sessionId, env));
+    const requireSid = () => {
+        sid ||= resolveLinkSessionId(root, options.sessionId, env);
+        bindSignalLaneSession(root, sid, env);
+        return sid;
+    };
     const links = rootDir(root);
     if (subcommand === "_deliver") {
         // Subagent hook events carry the parent's session_id. Delivering there would
         // drain the root's queue into the subagent, so leave the message queued.
         if (!sid || childContext || !["PostToolUse", "Stop"].includes(options.event ?? ""))
             return {};
+        bindSignalLaneSession(root, sid, env);
         if (options.event === "Stop" && (stopHookActive || env.HQ_STOP_DECISION_DELIVERABLE === "0"))
             return {};
         const pointer = readPointer(root, sid);

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

@@ -0,0 +1,154 @@
+export declare const LANE_OUTCOME_STATES: readonly ["done", "needs_decision", "partial"];
+export type LaneOutcomeState = (typeof LANE_OUTCOME_STATES)[number];
+export interface LaneOutcomeGathered {
+    label: string;
+    text: string;
+    ref?: string;
+}
+export interface LaneOutcome {
+    state: LaneOutcomeState;
+    outcome: string;
+    gathered: LaneOutcomeGathered[];
+    next_steps: string[];
+    decision_id?: string;
+}
+/** Envelope fields the consistency rules read. */
+export interface LaneOutcomeEnvelopeContext {
+    decision: string;
+    /** Number of envelope questions[] entries (0 when absent). */
+    questionCount: number;
+}
+export declare const LANE_OUTCOME_JSON_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["state", "outcome", "gathered", "next_steps"];
+    readonly properties: {
+        readonly state: {
+            readonly enum: readonly ["done", "needs_decision", "partial"];
+        };
+        readonly outcome: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly pattern: "\\S";
+        };
+        readonly gathered: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["label", "text"];
+                readonly properties: {
+                    readonly label: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "\\S";
+                    };
+                    readonly text: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "\\S";
+                    };
+                    readonly ref: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "\\S";
+                    };
+                };
+            };
+        };
+        readonly next_steps: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly pattern: "\\S";
+            };
+        };
+        readonly decision_id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly pattern: "\\S";
+        };
+    };
+    readonly allOf: readonly [{
+        readonly if: {
+            readonly properties: {
+                readonly state: {
+                    readonly const: "partial";
+                };
+            };
+        };
+        readonly then: {
+            readonly properties: {
+                readonly next_steps: {
+                    readonly minItems: 1;
+                };
+            };
+        };
+    }];
+    readonly description: string;
+};
+/**
+ * Envelope-level rules that tie the outcome block to other envelope fields.
+ * Merged into `LANE_ENVELOPE_JSON_SCHEMA.allOf`.
+ */
+export declare const LANE_OUTCOME_ENVELOPE_RULES: readonly [{
+    readonly if: {
+        readonly required: readonly ["outcome"];
+        readonly properties: {
+            readonly outcome: {
+                readonly properties: {
+                    readonly state: {
+                        readonly const: "needs_decision";
+                    };
+                };
+            };
+        };
+    };
+    readonly then: {
+        readonly anyOf: readonly [{
+            readonly properties: {
+                readonly outcome: {
+                    readonly required: readonly ["decision_id"];
+                };
+            };
+        }, {
+            readonly required: readonly ["questions"];
+            readonly properties: {
+                readonly questions: {
+                    readonly minItems: 1;
+                };
+            };
+        }];
+    };
+}, {
+    readonly if: {
+        readonly required: readonly ["outcome"];
+        readonly properties: {
+            readonly decision: {
+                readonly const: "blocked";
+            };
+        };
+    };
+    readonly then: {
+        readonly properties: {
+            readonly outcome: {
+                readonly properties: {
+                    readonly state: {
+                        readonly not: {
+                            readonly const: "done";
+                        };
+                    };
+                };
+            };
+        };
+    };
+}];
+/**
+ * Structural check only: field types, enums and the partial → next_steps rule.
+ * Used for stored LaneRecord.outcome values, where the envelope is not at hand.
+ */
+export declare function parseLaneOutcomeShape(raw: unknown, field?: string): LaneOutcome;
+/** Full check: shape plus the rules that read the surrounding envelope. */
+export declare function parseLaneOutcome(raw: unknown, context: LaneOutcomeEnvelopeContext): LaneOutcome;
+//# sourceMappingURL=outcome.d.ts.map