@indigoai-us/hq-cli 5.218.0 → 5.219.0

package/dist/lib/lanes/watcher-main.js

@@ -6,6 +6,20 @@
  * Requires HQ_ROOT in the environment.
  */
 import { runWatcherLoop } from "./watcher.js";
+import { LanesError } from "./errors.js";
+import { openMeshTransport } from "../mesh/client.js";
+import { CompanySelectionError } from "../../utils/company-selection-error.js";
+async function resolveQuestionActiveCompany() {
+    try {
+        const { company } = await openMeshTransport({});
+        return { slug: company.companySlug, uid: company.companyUid };
+    }
+    catch (err) {
+        if (!(err instanceof CompanySelectionError))
+            throw err;
+        throw new LanesError("question_company_unavailable", "Cannot raise a lane question because the active HQ company could not be resolved", {});
+    }
+}
 function main() {
     const laneId = process.argv[2]?.trim();
     const hqRoot = process.env.HQ_ROOT?.trim();
@@ -13,7 +27,9 @@ function main() {
         process.stderr.write("hq lanes watcher: requires lane id argv and HQ_ROOT in the environment\n");
         process.exit(1);
     }
-    void runWatcherLoop(hqRoot, laneId).catch((err) => {
+    void runWatcherLoop(hqRoot, laneId, {
+        resolveQuestionActiveCompany,
+    }).catch((err) => {
         process.stderr.write(`hq lanes watcher: ${err instanceof Error ? err.message : String(err)}${err instanceof Error && err.stack ? `\n${err.stack}` : ""}\n`);
         process.exit(1);
     });

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

@@ -31,7 +31,7 @@
  * Queue admission of the next lane when a slot frees is owned by the
  * periodic reconcile pass and is out of scope here.
  */
-import { ENVELOPE_INVALID_REASON, type LaneEnvelope, type LaneRecord, type LaneState } from "./types.js";
+import { ENVELOPE_INVALID_REASON, type LaneEnvelope, type LaneCompanyRef, type LaneRecord, type LaneState } from "./types.js";
 import { type QuotaSignal } from "./quota.js";
 import { type ProviderRejection } from "./provider-rejection.js";
 import type { AdmissionHost } from "./admission.js";
@@ -145,6 +145,7 @@ export interface ApplyTerminalOpts {
     envelopeRef?: string;
     envelopeValidationErrors?: string[];
     questionIndexes?: readonly number[];
+    activeCompany?: LaneCompanyRef | null;
     at?: string;
     quota?: QuotaSignal | null;
     /** Written to `terminal_details` with the model and account the run used. */
@@ -219,6 +220,8 @@ export interface WatcherLoopDeps {
     resolveAdmissionHost?: () => AdmissionHost;
     /** Spawn seams for account retry; host scope is supplied by the resolver above. */
     retrySpawnDeps?: Omit<SpawnLaneDeps, "admissionHost">;
+    /** Active-company fallback when an unscoped lane asks from its envelope. */
+    resolveQuestionActiveCompany?: () => Promise<LaneCompanyRef>;
 }
 /**
  * Wrap one mesh call. A failed emit is logged as `mesh_event_failed` with

package/dist/lib/lanes/watcher.js

@@ -34,7 +34,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { LanesError } from "./errors.js";
-import { raiseEnvelopeQuestions } from "./questions.js";
+import { questionRecordRefusalCode, raiseEnvelopeQuestions } from "./questions.js";
 import { isTerminalLaneState, ENVELOPE_INVALID_REASON, parseLaneEnvelope, STORY_STATUSES, } from "./types.js";
 import { laneStories, storyStatusForEnvelope } from "./stories.js";
 import { readLane, retryUpdateLane } from "./store.js";
@@ -309,12 +309,27 @@ export function applyTerminalToLane(hqRoot, laneId, classification, opts = {}) {
 export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, opts = {}) {
     const at = opts.at ?? new Date().toISOString();
     const existing = readLane(hqRoot, laneId);
+    let questionRefusalCode = null;
     if (!isTerminalLaneState(existing.state) &&
         classification.state === "awaiting_input" &&
         opts.envelope &&
         (opts.envelope.questions?.length ?? 0) > 0) {
-        raiseEnvelopeQuestions(hqRoot, existing, opts.envelope, opts.envelopeRef ?? "envelopes/unknown.json", at, opts.questionIndexes);
+        try {
+            raiseEnvelopeQuestions(hqRoot, existing, opts.envelope, opts.envelopeRef ?? "envelopes/unknown.json", at, opts.questionIndexes, opts.activeCompany);
+        }
+        catch (err) {
+            questionRefusalCode = questionRecordRefusalCode(err);
+            if (questionRefusalCode === null)
+                throw err;
+            process.stderr.write(`hq lanes watcher: terminal ask refused for ${laneId}: ${questionRefusalCode}\n`);
+        }
     }
+    const terminalClassification = questionRefusalCode === null
+        ? classification
+        : {
+            state: "failed",
+            reason: `question_record_refused:${questionRefusalCode}`,
+        };
     let changed = false;
     const updated = retryUpdateLane(hqRoot, laneId, "watcher", (current) => {
         const terminal = current.state === "done" ||
@@ -331,7 +346,7 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
         const next = {
             ...current,
             ...runResultFields(hqRoot, current),
-            state: classification.state,
+            state: terminalClassification.state,
             queued_reason: undefined,
             stalled: undefined,
             stalled_at: undefined,
@@ -340,9 +355,9 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
             envelope_validation_errors: opts.envelopeValidationErrors,
         };
         changed = true;
-        if (classification.reason) {
+        if (terminalClassification.reason) {
             next.terminal_reason =
-                classification.reason;
+                terminalClassification.reason;
         }
         if (opts.quota?.quota_reset_at) {
             next.quota_reset_at = opts.quota.quota_reset_at;
@@ -1054,11 +1069,19 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                             return;
                     }
                 }
+                const terminalLane = readLane(hqRoot, laneId);
+                const activeQuestionCompany = envelope?.decision === "ask" &&
+                    (envelope.questions?.length ?? 0) > 0 &&
+                    terminalLane.company === null &&
+                    terminalLane.mesh_company === undefined
+                    ? await deps.resolveQuestionActiveCompany?.()
+                    : undefined;
                 const terminalWrite = applyTerminalToLaneWithResult(hqRoot, laneId, classification, {
                     envelope,
                     envelopeRef: latest?.ref,
                     envelopeValidationErrors,
                     questionIndexes,
+                    activeCompany: activeQuestionCompany,
                     at: tick.emit.at,
                     quota,
                     providerRejection,
@@ -1074,7 +1097,7 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                 // lane_blocked; ask → lane_ask with the queue ids. After the state
                 // write, so a mesh failure can never leave the lane unclassified.
                 if (mesh && terminalWrite.changed) {
-                    if (envelope && latest) {
+                    if (envelope && latest && updated.state === classification.state) {
                         const questionIds = envelope.decision === "ask"
                             ? envelopeQuestionIds(laneId, latest.ref, envelope, questionIndexes)
                             : undefined;
@@ -1086,7 +1109,7 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                     }
                     else if (updated.state === "failed" || updated.state === "interrupted" ||
                         updated.state === "cancelled" || updated.state === "killed") {
-                        await emitMeshSoft(`lane_${updated.state}`, logDecision, tick.emit.at, (signal) => emitLaneTerminalStateEvent(mesh, updated, updated.state, classification.reason, signal), meshRequestTimeoutMs);
+                        await emitMeshSoft(`lane_${updated.state}`, logDecision, tick.emit.at, (signal) => emitLaneTerminalStateEvent(mesh, updated, updated.state, updated.terminal_reason ?? classification.reason, signal), meshRequestTimeoutMs);
                     }
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.218.0",
+  "version": "5.219.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {