@indigoai-us/hq-cli 5.345.198 → 5.345.200

package/dist/lib/lanes/spawn.js

@@ -1541,6 +1541,16 @@ function recoverRawJsonArrayField(rawText, field) {
     }
     return undefined;
 }
+/**
+ * Repair-turn guidance for the optional outcome block. Every repair prompt
+ * names the block, its three states, and the consistency rules so a model
+ * that wrote a malformed outcome can fix it in the single repair turn.
+ */
+export const LANE_OUTCOME_REPAIR_GUIDANCE = "Optional outcome block: if you include \"outcome\", it is an object with exactly the keys state, outcome, gathered, next_steps, and optional decision_id. " +
+    "state is one of done, needs_decision, partial. outcome is a non-empty string; gathered is an array of {label, text, ref?}; next_steps is an array of non-empty strings. " +
+    "state needs_decision requires a non-empty outcome.decision_id or a non-empty questions[] (with decision ask). " +
+    "state partial requires at least one next_steps entry. state done must not be combined with decision blocked. " +
+    "If you cannot satisfy these rules, remove the outcome block; the envelope is valid without it.";
 export function envelopeRepairPrompt(input) {
     const maxRawTextChars = 24_000;
     const rawText = input.rawText.length <= maxRawTextChars
@@ -1553,6 +1563,7 @@ export function envelopeRepairPrompt(input) {
             "Printing an envelope in the conversation or writing it to last-message.txt is not enough; write the JSON object directly to the expected file.",
             "If the task is unfinished, write decision: done, story_complete: false, and set story_status and story_complete_reason to describe the work that remains. The repair turn itself is never a reason for blocked.",
             "This repair turn only writes the missing envelope; do not resume the task.",
+            LANE_OUTCOME_REPAIR_GUIDANCE,
             "Schema:",
             JSON.stringify(LANE_ENVELOPE_JSON_SCHEMA, null, 2),
             `Write the corrected JSON object to ${input.envelopePath}, overwriting it. ` +
@@ -1564,6 +1575,7 @@ export function envelopeRepairPrompt(input) {
             `The file you wrote at ${input.envelopePath} is not a valid hq-lane-envelope.v1. This is the single repair turn: rewrite that file so it validates, and do nothing else.`,
             `Parser error: ${input.error}`,
             "For an ask question, include non-empty id, question, and context fields.",
+            LANE_OUTCOME_REPAIR_GUIDANCE,
             "Schema:", JSON.stringify(LANE_ENVELOPE_JSON_SCHEMA, null, 2),
             "Your previous output was:", rawText,
             `Write the corrected JSON object to ${input.envelopePath}, overwriting it. Output only that JSON. Do not add keys the schema does not name, and do not resume the task.`,
@@ -1645,6 +1657,7 @@ export function envelopeRepairPrompt(input) {
             ? "This is a JSON syntax error. Fix the exact reported line and column and remove the offending token or delimiter. Do not add trailing commas."
             : "This is a schema validation error. Correct the named field path and use only the allowed value(s) stated in the error.",
         "Keep every supplied value that is already valid. Do not invent next_check_at; it is optional. For decision=ask include non-empty id, question, and context fields; for decision=blocked include blocked_reason.",
+        LANE_OUTCOME_REPAIR_GUIDANCE,
         "Minimal valid envelope shape (retain your original decision and values when valid):",
         JSON.stringify(minimalEnvelope, null, 2),
         "Schema:",
@@ -2675,6 +2688,10 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         : undefined;
     const childEnv = workerEnv(env, { envVar: resolved.envVar, home: remoteControlHome ?? resolved.home }, lane.lane_id, hqRoot, autoCompactTokens, lane.mesh_company ?? lane.company ?? undefined, workerPolicyDir, lane.registry_worker, undefined, laneWorkerSessionEnv(existing, plan.mode === "resume" ? plan.session_id : remoteSessionId));
     const laneTurnId = randomUUID();
+    if (lane.signal_link)
+        childEnv.HQ_LANE_SIGNAL_LINK = lane.signal_link;
+    else
+        delete childEnv.HQ_LANE_SIGNAL_LINK;
     childEnv.HQ_LANE_TURN_ID = laneTurnId;
     const fingerprint = (deps.buildFingerprint ?? laneStartFingerprint)(hqRoot, childEnv);
     const model = resolveLaneModel({
@@ -3322,6 +3339,10 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
         ? providerAutoCompactTokens(config.providers.claude)
         : undefined;
     const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot, autoCompactTokens, lane.mesh_company ?? lane.company ?? undefined, workerPolicyDir, lane.registry_worker, undefined, laneWorkerSessionEnv(lane, mode === "resume" && sessionId !== null ? sessionId : undefined));
+    if (lane.signal_link)
+        childEnv.HQ_LANE_SIGNAL_LINK = lane.signal_link;
+    else
+        delete childEnv.HQ_LANE_SIGNAL_LINK;
     const accountCfg = config.providers[lane.provider].accounts[resolved.id];
     const model = resolveLaneModel({
         cliModel: pinnedModel,

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

@@ -1,6 +1,9 @@
 import * as fs from "node:fs";
 import { type OutpostIdentity } from "./admission-host.js";
 import { type AttributionHistoryEntry, type LaneRecord, type LaneWriter, type QuestionRecord, type RoutingHistoryEntry, type SeniorHistoryEntry } from "./types.js";
+/** Signal identity is company-scoped and survives terminal lane states. */
+export declare function findLaneBySignal(company: string, signalId: string, hqRoot?: string): LaneRecord | undefined;
+export declare function listLanesBySource(company: string, sourceRef: string, hqRoot?: string): LaneRecord[];
 export declare const LANES_STORE_REL: string;
 export declare const LANE_RECORDS_DIR = "lanes";
 export declare const QUESTION_RECORDS_DIR = "questions";

package/dist/lib/lanes/store.js

@@ -19,8 +19,52 @@ import { readOutpostIdentity } from "./admission-host.js";
 import { LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesError, isLaneVersionConflict, } from "./errors.js";
 import { HISTORY_CAP, HOST_KINDS, LANE_STORY_STATUSES, LANE_SCHEMA_VERSION, QUESTION_SCHEMA_VERSION, SENIOR_KINDS, isHostKind, isLaneProvider, isQueuedReason, isLaneState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseMajorSchema, REQUIRED_LANE_RECORD_FIELDS, LANE_FIELD_WRITERS, LANE_RUNNERS, LANE_WRITERS, } from "./types.js";
 import { laneStories } from "./stories.js";
+import { parseLaneOutcomeShape } from "./outcome.js";
 import { laneStoryLedgerEnabled, syncLaneToProjectStoryLedger, validateProjectStories, } from "./story-ledger.js";
 import { liveOwnerMaxMs, reclaimStaleLock } from "./stale-lock.js";
+/** Signal identity is company-scoped and survives terminal lane states. */
+export function findLaneBySignal(company, signalId, hqRoot = resolveStoreHqRoot()) {
+    return readAllLanes(hqRoot).find(lane => lane.company?.slug === company && lane.signal?.signal_id === signalId);
+}
+export function listLanesBySource(company, sourceRef, hqRoot = resolveStoreHqRoot()) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(company))
+        throw new LaneSchemaError("Invalid company slug");
+    const lanes = readAllLanes(hqRoot).filter(lane => lane.company?.slug === company && lane.signal?.source_ref === sourceRef);
+    if (!lanes.length)
+        return lanes;
+    // Daily indexes preserve extraction order, which can differ from dispatch order.
+    const index = path.join(hqRoot, "companies", company, "signals", "_index");
+    const order = new Map();
+    let files;
+    try {
+        files = fs.readdirSync(index).filter(name => name.endsWith(".json")).sort();
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        files = [];
+    }
+    if (files.length) {
+        const expected = path.join(fs.realpathSync(hqRoot), "companies", company, "signals", "_index");
+        if (fs.realpathSync(index) !== expected)
+            throw new LaneSchemaError("Signal index must stay within this company");
+        for (const file of files) {
+            const filePath = path.join(index, file);
+            if (fs.realpathSync(filePath) !== path.join(expected, file))
+                throw new LaneSchemaError("Signal index file must stay within this company");
+            const rows = JSON.parse(fs.readFileSync(filePath, "utf8"));
+            if (!Array.isArray(rows))
+                throw new LaneSchemaError("Signal index must contain an array");
+            for (const row of rows) {
+                if (row && typeof row === "object" && row.source_ref === sourceRef && typeof row.signal_id === "string" && !order.has(row.signal_id)) {
+                    order.set(row.signal_id, order.size);
+                }
+            }
+        }
+    }
+    return lanes.sort((a, b) => (order.get(a.signal.signal_id) ?? Number.MAX_SAFE_INTEGER) - (order.get(b.signal.signal_id) ?? Number.MAX_SAFE_INTEGER)
+        || a.created_at.localeCompare(b.created_at) || a.lane_id.localeCompare(b.lane_id));
+}
 export const LANES_STORE_REL = path.join("workspace", "lanes");
 export const LANE_RECORDS_DIR = "lanes";
 export const QUESTION_RECORDS_DIR = "questions";
@@ -451,6 +495,17 @@ 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.signal !== undefined) {
+        if (!raw.signal || typeof raw.signal !== "object" || Array.isArray(raw.signal)) {
+            throw new LaneSchemaError("signal must be an object", { field: "signal" });
+        }
+        const signal = raw.signal;
+        for (const field of ["signal_id", "type", "source_ref", "title"])
+            requireString(signal[field], "signal." + field);
+    }
+    if (raw.signal_link !== undefined && (typeof raw.signal_link !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(raw.signal_link) || !raw.signal)) {
+        throw new LaneSchemaError("signal_link requires a signal and a valid link id", { field: "signal_link" });
+    }
     if (raw.remote_control !== undefined && (raw.remote_control !== true || raw.provider !== "claude")) {
         throw new LaneSchemaError("remote_control requires a Claude lane", {
             path: filePath,
@@ -666,6 +721,15 @@ export function parseLaneRecord(raw, filePath) {
         raw.envelope_validation_errors.some((error) => typeof error !== "string" || error.trim() === ""))) {
         throw new LaneSchemaError("envelope_validation_errors must be a non-empty array of non-empty strings", { path: filePath, field: "envelope_validation_errors" });
     }
+    if (raw.outcome !== undefined) {
+        try {
+            parseLaneOutcomeShape(raw.outcome);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new LaneSchemaError(`outcome is malformed: ${message}`, { path: filePath, field: "outcome" });
+        }
+    }
     if (raw.fallback_question_cancellation_failures !== undefined) {
         if (!Array.isArray(raw.fallback_question_cancellation_failures)) {
             throw new LaneSchemaError("fallback_question_cancellation_failures must be an array", {

package/dist/lib/lanes/story-ledger.d.ts

@@ -1,3 +1,4 @@
+import type { LaneOutcome } from "./outcome.js";
 import { type LaneRecord, type LaneState } from "./types.js";
 export declare const LANE_STORY_LEDGER_FLAG = "lanes.story-ledger";
 declare const STORY_STATES: readonly ["todo", "in_progress", "review", "waiting", "blocked", "done", "dropped"];
@@ -55,6 +56,8 @@ export interface LaneStatusSnapshot {
         state: LaneState;
         queued_reason: string | null;
         fingerprint: string | null;
+        /** The last envelope's outcome block, or null when it carried none. */
+        outcome: LaneOutcome | null;
     }>;
     prs: Array<{
         story_id: string;

package/dist/lib/lanes/story-ledger.js

@@ -813,6 +813,7 @@ export function buildLaneStatusSnapshot(input) {
         state: lane.state,
         queued_reason: lane.queued_reason ?? null,
         fingerprint: lane.fingerprint ?? null,
+        outcome: lane.outcome ?? null,
     }));
     const projectPrs = [];
     const blockers = [];

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

@@ -3,6 +3,7 @@
  * §4, §5.5, §6.2). Finite sets are string-literal unions plus `const` arrays
  * so the command layer can validate flags explicitly.
  */
+import { type LaneOutcome } from "./outcome.js";
 export declare const LANE_SCHEMA_VERSION: "hq-lane.v1";
 export declare const QUESTION_SCHEMA_VERSION: "hq-lane-question.v1";
 export declare const ENVELOPE_SCHEMA_VERSION: "hq-lane-envelope.v1";
@@ -85,6 +86,76 @@ export declare const LANE_ENVELOPE_JSON_SCHEMA: {
             readonly type: readonly ["string", "null"];
             readonly description: "Optional worker fingerprint (hq fingerprint self); null when it could not be built. Older readers ignore it.";
         };
+        readonly outcome: {
+            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;
+        };
     };
     readonly allOf: readonly [{
         readonly if: {
@@ -171,6 +242,57 @@ export declare const LANE_ENVELOPE_JSON_SCHEMA: {
                 };
             };
         };
+    }, {
+        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";
+                            };
+                        };
+                    };
+                };
+            };
+        };
     }];
     readonly description: string;
 };
@@ -523,7 +645,15 @@ export interface LaneStory {
     verified_at?: string;
     verified_by?: SeniorRef;
 }
+export interface LaneSignal {
+    signal_id: string;
+    type: string;
+    source_ref: string;
+    title: string;
+}
 export interface LaneRecord {
+    signal?: LaneSignal;
+    signal_link?: string;
     schema_version: typeof LANE_SCHEMA_VERSION | string;
     lane_id: string;
     /** CLI release that most recently wrote this lane record. Absent on legacy rows. */
@@ -729,6 +859,11 @@ export interface LaneRecord {
     story_status?: StoryStatus;
     /** Envelope parser failures retained when a usable ask is recovered. */
     envelope_validation_errors?: string[];
+    /**
+     * Copied from the last ingested envelope's optional `outcome` block.
+     * Cleared when a later envelope carries no outcome.
+     */
+    outcome?: LaneOutcome;
     /** Set by the reconcile pass when `--timeout` has passed (spec §5.7). */
     overdue?: boolean;
     overdue_at?: string;
@@ -1027,6 +1162,8 @@ export interface LaneEnvelope {
     story_complete_reason?: string;
     /** The worker's fingerprint, or null when it could not be built. Optional. */
     fingerprint?: string | null;
+    /** Optional structured result block (see outcome.ts). */
+    outcome?: LaneOutcome;
 }
 export interface AccountConfig {
     /** Company slug or UID owning this account. Untagged accounts are personal. */

package/dist/lib/lanes/types.js

@@ -4,6 +4,7 @@
  * so the command layer can validate flags explicitly.
  */
 import { LanesError, LaneSchemaError } from "./errors.js";
+import { LANE_OUTCOME_ENVELOPE_RULES, LANE_OUTCOME_JSON_SCHEMA, parseLaneOutcome, } from "./outcome.js";
 export const LANE_SCHEMA_VERSION = "hq-lane.v1";
 export const QUESTION_SCHEMA_VERSION = "hq-lane-question.v1";
 export const ENVELOPE_SCHEMA_VERSION = "hq-lane-envelope.v1";
@@ -53,6 +54,7 @@ export const LANE_ENVELOPE_JSON_SCHEMA = {
             type: ["string", "null"],
             description: "Optional worker fingerprint (hq fingerprint self); null when it could not be built. Older readers ignore it.",
         },
+        outcome: LANE_OUTCOME_JSON_SCHEMA,
     },
     allOf: [
         {
@@ -80,11 +82,16 @@ export const LANE_ENVELOPE_JSON_SCHEMA = {
                 else: { not: { required: ["story_complete_reason"] } },
             },
         },
+        ...LANE_OUTCOME_ENVELOPE_RULES,
     ],
     description: "questions is present and non-empty exactly when decision is ask. " +
         "blocked_reason is present exactly when decision is blocked. " +
         "story_complete true requires story_status done; story_complete false requires story_status other than done; " +
-        "story_complete_reason is required whenever story_complete is present.",
+        "story_complete_reason is required whenever story_complete is present. " +
+        "outcome is optional; outcome.state is done, needs_decision or partial. " +
+        "needs_decision requires outcome.decision_id or a non-empty questions[]; " +
+        "partial requires at least one outcome.next_steps entry; " +
+        "outcome.state done is rejected when decision is blocked.",
 };
 export const LANE_STATES = [
     "queued",
@@ -247,6 +254,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 = {
+    signal: ["creator"], signal_link: ["creator"],
     schema_version: ["creator"], lane_id: ["creator"], written_by_version: [], owner_written_by_version: [], company: ["creator", "command"], company_history: ["command"],
     project_id: ["command"], story_id: ["command"], no_story_reason: ["creator", "command"], focus_overrides: ["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"],
@@ -260,7 +268,7 @@ export const LANE_FIELD_WRITERS = {
     provider: ["creator", "command"], runner: ["creator"], remote_control: ["creator"], remote_control_title: ["creator"], provider_source: ["creator", "command"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_source: ["creator", "command"], profile_settings_pinned: ["command"], account_selection: ["creator", "command"], account_pick: ["creator"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], fallback_question_cancellation_failures: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], attribution_history: ["command", "watcher", "reconcile"], story_switch_pending: ["command", "watcher", "reconcile"], story_switch_unacknowledged: ["command", "watcher", "reconcile"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn", "command"], effort_source: ["creator", "spawn", "command"], fast_mode: ["spawn"],
-    last_message_at: ["creator", "command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
+    last_message_at: ["creator", "command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"], outcome: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command", "reconcile"], settings_history: ["command"], pending_settings: ["command", "spawn"], interrupted_at: ["command", "watcher", "reconcile", "spawn"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile", "spawn", "command"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],
@@ -322,6 +330,7 @@ export function parseLaneEnvelope(raw, options = {}) {
         "story_complete",
         "story_complete_reason",
         "fingerprint",
+        "outcome",
     ].includes(key));
     if (extra.length > 0) {
         throw new LaneSchemaError(`Lane envelope rejects unknown properties: ${extra.join(", ")}`, { extra });
@@ -453,6 +462,12 @@ export function parseLaneEnvelope(raw, options = {}) {
     if (typeof raw.blocked_reason === "string") {
         envelope.blocked_reason = raw.blocked_reason;
     }
+    if (raw.outcome !== undefined) {
+        envelope.outcome = parseLaneOutcome(raw.outcome, {
+            decision: envelope.decision,
+            questionCount: envelope.questions?.length ?? 0,
+        });
+    }
     return envelope;
 }
 //# sourceMappingURL=types.js.map

package/dist/lib/lanes/watcher.js

@@ -425,6 +425,8 @@ function applyTerminalToLaneWithResult(hqRoot, laneId, classification, opts = {}
                 },
                 ...(envelope.decision !== "blocked" ? { keep_alive_blocked_resume_streak: 0 } : {}),
                 envelope_validation_errors: opts.envelopeValidationErrors,
+                // The last envelope's outcome block; undefined clears a stale one.
+                outcome: envelope.outcome,
             };
             if (!approvalGate.violation && approvalGate.approvedIdsToConsume.length > 0) {
                 next.registry_worker_approval_history = approvalGate.approvedIdsToConsume.reduce((history, approvalId) => appendCappedHistory(history, {
@@ -509,6 +511,8 @@ function applyTerminalToLaneWithResult(hqRoot, laneId, classification, opts = {}
             const storySwitch = applyStorySwitchEnvelope(current, envelope, at, envelopeRef);
             if (envelope.decision !== "blocked")
                 next.keep_alive_blocked_resume_streak = 0;
+            // The last envelope's outcome block; undefined clears a stale one.
+            next.outcome = envelope.outcome;
             next.last_envelope = {
                 ref: envelopeRef,
                 decision: envelope.decision,

package/dist/lib/live-meetings.d.ts

@@ -0,0 +1,19 @@
+export interface LiveMeetingBot {
+    meetingId?: string;
+    meetingUrl?: string;
+    recallBotId?: string;
+    botId?: string;
+    companyId?: string;
+    meetingTitle?: string;
+    title?: string;
+    status?: string;
+    scheduledStartTime?: string;
+    createdAt?: string;
+    linesSoFar?: number;
+    transcriptLineCount?: number;
+    sourceLanded?: boolean;
+    savedTranscriptPath?: string;
+}
+/** The attended list used by meetings live and the Executive's poll producer. */
+export declare function fetchAttendedLiveBots(token: string, companyId: string, strict?: boolean, signal?: AbortSignal): Promise<LiveMeetingBot[]>;
+//# sourceMappingURL=live-meetings.d.ts.map

package/dist/lib/live-meetings.js

@@ -0,0 +1,23 @@
+import { vaultApiFetch } from "../utils/vault-api.js";
+/** The attended list used by meetings live and the Executive's poll producer. */
+export async function fetchAttendedLiveBots(token, companyId, strict = false, signal) {
+    try {
+        const res = await vaultApiFetch({ token, path: "/v1/meetings", query: { companyId, view: "live" }, ...(signal ? { signal } : {}) });
+        if (!res.ok) {
+            if (strict)
+                throw new Error("Could not list attended meetings");
+            return [];
+        }
+        const data = (await res.json());
+        if (strict && !Array.isArray(data.bots))
+            throw new Error("Invalid attended meetings response");
+        return Array.isArray(data.bots) ? data.bots : [];
+    }
+    catch (err) {
+        if (strict)
+            throw err;
+        // Older servers and offline callers retain the CLI's own-notetaker list.
+        return [];
+    }
+}
+//# sourceMappingURL=live-meetings.js.map

package/dist/lib/mesh/api.js

@@ -9,6 +9,7 @@ import { ensureCognitoToken, isMachineIdentity } from "../../utils/cognito-sessi
 import { peekIdToken } from "../../utils/id-token.js";
 import { getCompanyUid, vaultApiFetch } from "../../utils/vault-api.js";
 import { meshCacheRoot, removeSessionFallbackFiles, writeMeshCacheFile, } from "./cache.js";
+import { gatedInteractiveLogin } from "../../utils/interactive-caller.js";
 const PRINCIPAL_UID = /^(prs|agt)_/;
 export const STORY_STATUSES = new Set([
     "queued",
@@ -183,7 +184,7 @@ export async function requireToken(opts = {}) {
     // hard policy indigo-agent-caller-resolution-id-token, agent claims ride
     // the ID token only; the server is correct to require it. Humans keep the
     // person access token (unchanged).
-    const interactive = opts.interactive ?? true;
+    const interactive = gatedInteractiveLogin(opts.interactive ?? true);
     if (isMachineIdentity()) {
         return ensureCognitoToken({ tokenSource: "machine", interactive });
     }

package/dist/lib/mesh/live/daemon/doctor.js

@@ -12,7 +12,7 @@ import { workContextRoot } from "../../../work-context/paths.js";
 import { outboxQuarantineStatusEnabled } from "../../../work-context/outbox-quarantine-status-flag.js";
 import { formatDroppedPresenceCompany } from "./credentials.js";
 import { formatOwnerPushStatus, ownerPushStatusForAccount, readOwnerInboxPushState, } from "./owner-inbox-push.js";
-import { countDistinctHeldEvents, countJsonlLines, countUnattributedEvents, } from "../spool.js";
+import { countDistinctHeldEvents, countJsonlLines, countUnattributedEvents, forEachJsonlLine, } from "../spool.js";
 import { workMeshDeadLetterPath, workMeshHeldPath, workMeshRoot, workMeshSpoolPath, } from "../paths.js";
 import { daemonDir, daemonPidPath } from "./paths.js";
 import { readEmitState } from "../emit.js";
@@ -31,11 +31,10 @@ function oldestJsonlAgeMs(filePath, nowMs) {
     if (!fs.existsSync(filePath))
         return undefined;
     try {
-        const text = fs.readFileSync(filePath, "utf8");
         let oldest;
-        for (const line of text.split("\n")) {
+        forEachJsonlLine(filePath, (line) => {
             if (!line.trim())
-                continue;
+                return;
             try {
                 const obj = JSON.parse(line);
                 const at = (typeof obj.at === "string" && obj.at) ||
@@ -43,10 +42,10 @@ function oldestJsonlAgeMs(filePath, nowMs) {
                     (obj.event && typeof obj.event.at === "string" && obj.event.at) ||
                     undefined;
                 if (!at)
-                    continue;
+                    return;
                 const t = Date.parse(at);
                 if (!Number.isFinite(t))
-                    continue;
+                    return;
                 const age = nowMs - t;
                 if (oldest === undefined || age > oldest)
                     oldest = age;
@@ -54,7 +53,7 @@ function oldestJsonlAgeMs(filePath, nowMs) {
             catch {
                 /* skip */
             }
-        }
+        });
         return oldest;
     }
     catch {

package/dist/lib/mesh/live/daemon/run.d.ts

@@ -1,13 +1,3 @@
-/**
- * hq mesh daemon run — single-instance resident process.
- *
- * - pid lock at ~/.hq/work-mesh/daemon/pid
- * - fs.watch spool + 2s debounce; flush at least every 10s (US-008 path)
- * - replay context outbox
- * - board.md refresh for bound sessions ≤ every 60s
- * - MQTT presence (contract-3)
- * - SIGTERM/SIGINT: flush once more, MQTT DISCONNECT (server derives offline), exit
- */
 import { type DeliverFn } from "../../../work-context/outbox.js";
 import { type SessionEventsPoster } from "../session-events-client.js";
 import { type FlushSummary } from "../flush.js";

package/dist/lib/mesh/live/daemon/run.js

@@ -1,3 +1,4 @@
+import { reportingRuntimeAllowed } from "../reporting-privacy.js";
 /**
  * hq mesh daemon run — single-instance resident process.
  *
@@ -380,6 +381,8 @@ export async function runMeshDaemon(deps = {}) {
                 baseUrl: resolveVaultApiBase(env),
             });
             return flushSessionEvents({
+                env,
+                reportingAllowed: () => reportingRuntimeAllowed(machineIdentity, env),
                 workMeshRoot: meshRoot,
                 workContextRoot: ctxRoot,
                 poster,

package/dist/lib/mesh/live/emit.d.ts

@@ -1,14 +1,3 @@
-/**
- * Direct-emit orchestration (owner decision 2026-09-08). One invocation:
- *   1. drains the local retry file (prior failures),
- *   2. appends the new event(s),
- *   3. POSTs /v1/mesh/events in batches with a short bounded retry,
- *   4. keeps only network/5xx/429-failed or unaccounted events for next time,
- *   5. records lastPostAt + per-event status counts for `hq mesh doctor`.
- *
- * accepted / unassigned / rejected are all terminal (rejected is dropped with a
- * count — never re-posted). No long-lived process, spool, or held queue.
- */
 import { type EmitPoster, type EmitEventStatus } from "./emit-client.js";
 import { type RandomFn, type SleepFn } from "./backoff.js";
 export interface EmitStateFile {
@@ -23,6 +12,8 @@ export interface EmitStateFile {
 export declare function emitStatePath(workMeshRoot: string): string;
 export declare function readEmitState(workMeshRoot: string): EmitStateFile | null;
 export interface EmitEventsDeps {
+    env?: NodeJS.ProcessEnv;
+    reportingAllowed?: () => Promise<boolean>;
     workMeshRoot: string;
     poster: EmitPoster;
     /** New events to emit this invocation (may be empty — just drain retry). */

package/dist/lib/mesh/live/emit.js

@@ -1,3 +1,4 @@
+import { reportingLocallyDisabled, mayEmitConversation } from "./reporting-privacy.js";
 /**
  * Direct-emit orchestration (owner decision 2026-09-08). One invocation:
  *   1. drains the local retry file (prior failures),
@@ -90,10 +91,27 @@ export async function emitEvents(deps) {
         statuses: { accepted: 0, unassigned: 0, rejected: 0 },
         rejections: [],
     };
+    const env = deps.env ?? process.env;
+    if (reportingLocallyDisabled(env) || (deps.reportingAllowed && !(await deps.reportingAllowed()))) {
+        const written = writeEmitRetry(deps.workMeshRoot, combined, retryMax);
+        return { ...summary, attempted: 0, retained: written.written,
+            retryDepth: written.written, droppedOverflow: written.dropped };
+    }
+    const allowed = combined.filter(event => {
+        if (mayEmitConversation(event, env))
+            return true;
+        summary.rejected += 1;
+        summary.statuses.rejected += 1;
+        const eventId = eventIdOf(event);
+        if (eventId)
+            summary.rejections.push({ eventId, code: "PERSONAL_OR_UNATTRIBUTED" });
+        return false;
+    });
+    summary.attempted = allowed.length;
     const keep = [];
     let anyPosted = false;
-    for (let i = 0; i < combined.length; i += MESH_EVENTS_BATCH_MAX) {
-        const chunk = combined.slice(i, i + MESH_EVENTS_BATCH_MAX);
+    for (let i = 0; i < allowed.length; i += MESH_EVENTS_BATCH_MAX) {
+        const chunk = allowed.slice(i, i + MESH_EVENTS_BATCH_MAX);
         summary.batches += 1;
         let result = await deps.poster(chunk);
         for (let attempt = 1; attempt < maxAttempts && !result.ok && result.retryable; attempt += 1) {