@indigoai-us/hq-cli 5.291.0 → 5.293.0

package/dist/commands/core-delegate.d.ts

@@ -1,6 +1,34 @@
 /** Native implementations of the five `hq core delegate` shell companions. */
 import { Command } from "commander";
 export declare const CORE_NATIVE_DELEGATE_FLAG = "core-native-delegate";
+export type DelegateContext = {
+    cwd: string;
+    root?: string;
+};
+type CommandResult = {
+    code: number;
+    stdout?: string;
+    stderr?: string;
+};
+export declare function subprocess(command: string, args: string[], cwd: string, options?: {
+    input?: Buffer | string;
+    stdinFd?: number;
+    stderr?: "inherit" | "ignore" | "pipe";
+    stdout?: "capture" | "inherit" | "ignore";
+}): CommandResult;
+type JsonRecord = Record<string, unknown>;
+export declare function isRecord(value: unknown): value is JsonRecord;
+export declare function readJsonText(text: string): unknown;
+export declare function readJsonFile(file: string): unknown;
+export declare function jqFallback(value: unknown, fallback?: unknown): unknown;
+export declare function jsonAt(value: unknown, dottedPath: string): unknown;
+export declare function rawJsonValue(value: unknown): string;
+export declare function jqRawPath(value: unknown, dottedPath: string, fallback?: unknown): string;
+export declare function jqRawPaths(value: unknown, dottedPaths: string[], fallback?: unknown): string;
+export declare function requireRecord(value: unknown, property: string): JsonRecord;
+export declare function moveFile(source: string, target: string): void;
+export declare function writeJsonAtomically(target: string, value: unknown, siblingTemp?: boolean): void;
 /** Register the Wave 1a delegate commands and preserve the shell rollback path. */
 export declare function registerCoreDelegateCommand(core: Command): void;
+export {};
 //# sourceMappingURL=core-delegate.d.ts.map

package/dist/commands/core-delegate.js

@@ -8,6 +8,7 @@ import { resolveProcessFlagGate } from "../lib/flag-registry.js";
 import { describeCoreCommand } from "./core-command-catalog.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { runBundledScript } from "../utils/run-bundled-script.js";
+import { registerCoreDelegateW1b } from "./core-delegate-w1b.js";
 export const CORE_NATIVE_DELEGATE_FLAG = "core-native-delegate";
 const SCRIPT_ASSETS = {
     resolve: "core/scripts/hq-delegate-resolve.sh",
@@ -60,13 +61,13 @@ function commandPath(name, cwd = process.cwd()) {
 function commandExists(name, cwd = process.cwd()) {
     return commandPath(name, cwd) !== undefined;
 }
-function subprocess(command, args, cwd, options = {}) {
+export function subprocess(command, args, cwd, options = {}) {
     const result = spawnSync(command, args, {
         cwd,
         env: process.env,
         input: options.input,
         encoding: "utf8",
-        stdio: [options.stdinFd ?? "inherit", options.stdout === "inherit" ? "inherit" : options.stdout === "ignore" ? "ignore" : "pipe", options.stderr ?? "inherit"],
+        stdio: [options.stdinFd ?? "inherit", options.stdout === "inherit" ? "inherit" : options.stdout === "ignore" ? "ignore" : "pipe", options.stderr === "pipe" ? "pipe" : options.stderr ?? "inherit"],
     });
     if (result.error) {
         return { code: 127, stderr: result.error.message, stdout: "" };
@@ -77,10 +78,10 @@ function subprocess(command, args, cwd, options = {}) {
         stderr: typeof result.stderr === "string" ? result.stderr : "",
     };
 }
-function isRecord(value) {
+export function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function readJsonText(text) {
+export function readJsonText(text) {
     return JSON.parse(text);
 }
 function jqParseDiagnostic(text) {
@@ -92,7 +93,7 @@ function jqParseDiagnostic(text) {
     }
     return "jq: parse error: Invalid JSON text\n";
 }
-function readJsonFile(file) {
+export function readJsonFile(file) {
     return readJsonText(fs.readFileSync(file, "utf8"));
 }
 function jqValid(file) {
@@ -108,24 +109,24 @@ function jqValid(file) {
 function jqTruthy(value) {
     return value !== null && value !== undefined && value !== false;
 }
-function jqFallback(value, fallback = "") {
+export function jqFallback(value, fallback = "") {
     return jqTruthy(value) ? value : fallback;
 }
-function jsonAt(value, dottedPath) {
+export function jsonAt(value, dottedPath) {
     let current = value;
     for (const part of dottedPath.split(".")) {
         current = isRecord(current) ? current[part] : undefined;
     }
     return current;
 }
-function rawJsonValue(value) {
+export function rawJsonValue(value) {
     return serializeJqJson(value, "raw").replace(/\n+$/, "");
 }
-function jqRawPath(value, dottedPath, fallback = "") {
+export function jqRawPath(value, dottedPath, fallback = "") {
     const found = jsonAt(value, dottedPath);
     return found === undefined && fallback === "" ? "" : rawJsonValue(jqFallback(found, fallback));
 }
-function jqRawPaths(value, dottedPaths, fallback = "") {
+export function jqRawPaths(value, dottedPaths, fallback = "") {
     for (const dottedPath of dottedPaths) {
         const found = jsonAt(value, dottedPath);
         if (jqTruthy(found))
@@ -133,13 +134,13 @@ function jqRawPaths(value, dottedPaths, fallback = "") {
     }
     return rawJsonValue(fallback);
 }
-function requireRecord(value, property) {
+export function requireRecord(value, property) {
     const result = isRecord(value) ? value[property] : undefined;
     if (!isRecord(result))
         throw new TypeError(`Cannot update non-object field ${property}`);
     return result;
 }
-function moveFile(source, target) {
+export function moveFile(source, target) {
     try {
         fs.renameSync(source, target);
     }
@@ -151,7 +152,7 @@ function moveFile(source, target) {
         fs.unlinkSync(source);
     }
 }
-function writeJsonAtomically(target, value, siblingTemp = false) {
+export function writeJsonAtomically(target, value, siblingTemp = false) {
     const serialized = serializeJqJson(value, "pretty");
     if (siblingTemp) {
         const temporary = `${target}.tmp`;
@@ -983,5 +984,6 @@ export function registerCoreDelegateCommand(core) {
         });
         describeCoreCommand(command, { execution: "native", asset: SCRIPT_ASSETS[name], root: rootMode });
     }
+    registerCoreDelegateW1b(delegate, core);
 }
 //# sourceMappingURL=core-delegate.js.map

package/dist/commands/core-handoff.js

@@ -46,6 +46,66 @@ const OPEN_STEPS_UNKNOWN_USAGE = `# hq-core: public
 set -uo pipefail
 HQ_ROOT="\${HQ_ROOT:-\${CLAUDE_PROJECT_DIR:-$(cd "$(dirname "\${BASH_SOURCE[0]}")/../.." && pwd)}}"
 `;
+const SESSION_ID_ENV_KEYS = [
+    "HQ_SESSION_ID",
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_SESSION_ID",
+    "CODEX_SESSION_ID",
+    "CODEX_THREAD_ID",
+    "GROK_SESSION_ID",
+];
+function validSessionId(value) {
+    return value !== "" && value !== "." && value !== ".." && /^[A-Za-z0-9._-]+$/.test(value);
+}
+function resolveSessionId(root) {
+    for (const key of SESSION_ID_ENV_KEYS) {
+        const value = (process.env[key] ?? "").replace(/\s/g, "");
+        if (validSessionId(value))
+            return value;
+    }
+    const current = path.join(root, "workspace/sessions/.current");
+    try {
+        const value = fs.readFileSync(current, "utf8").replace(/\s/g, "");
+        return validSessionId(value) ? value : "";
+    }
+    catch {
+        return "";
+    }
+}
+function boundSessionCompany(root) {
+    const sessionId = resolveSessionId(root);
+    if (!sessionId)
+        return "";
+    const metadata = path.join(root, "workspace/sessions", sessionId, "meta.yaml");
+    let contents;
+    try {
+        contents = fs.readFileSync(metadata, "utf8");
+    }
+    catch {
+        return "";
+    }
+    const line = contents.split(/\r?\n/).find((entry) => /^\s*company_slug:/.test(entry));
+    if (!line)
+        return "";
+    const company = (line.replace(/^\s*company_slug:\s*/, "").replace(/^"|"$/g, ""));
+    return /^[a-z][a-z0-9_-]*$/.test(company) ? company : "";
+}
+class HandoffJsonOptionError extends Error {
+    flag;
+    constructor(flag, cause) {
+        super(cause instanceof Error ? cause.message : String(cause));
+        this.flag = flag;
+        this.name = "HandoffJsonOptionError";
+    }
+}
+function parseHandoffJson(value, flag) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        throw new HandoffJsonOptionError(flag, error);
+    }
+}
 function nowFor(context) {
     return context.now?.() ?? new Date();
 }
@@ -259,7 +319,7 @@ export function runHandoffOpenSteps(args, context) {
                     title: (isRecord(thread.metadata) ? thread.metadata.title : undefined) ?? "",
                     created: thread.created_at,
                     id: step.id,
-                    step: step.step,
+                    step: step.step ?? null,
                 });
             }
         }
@@ -540,7 +600,7 @@ function resolveFinalizeOptions(args) {
             return { values, error: { code: 2, stdout: "", stderr: `Unknown arg: ${key}\n` } };
         if (index + 1 >= args.length) {
             const shellAsset = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../assets/scaffold", ASSETS.finalize);
-            return { values, error: { code: 1, stdout: "", stderr: `${shellAsset}: line 91: $2: unbound variable\n` } };
+            return { values, error: { code: 1, stdout: "", stderr: `${shellAsset}: line 93: $2: unbound variable\n` } };
         }
         values[target] = args[index + 1] ?? "";
         index += 2;
@@ -605,10 +665,10 @@ export function runHandoffFinalize(args, context) {
             const file = path.isAbsolute(values.filesTouchedFile) ? values.filesTouchedFile : path.join(root, values.filesTouchedFile);
             if (!fs.existsSync(file))
                 return { code: 3, stdout: "", stderr: `handoff-finalize: --files-touched-json-file not found: ${values.filesTouchedFile}\n` };
-            touchedValue = JSON.parse(fs.readFileSync(file, "utf8"));
+            touchedValue = parseHandoffJson(fs.readFileSync(file, "utf8"), "--files-touched-json-file");
         }
         else {
-            touchedValue = JSON.parse(values.filesTouched);
+            touchedValue = parseHandoffJson(values.filesTouched, "--files-touched-json");
         }
         const touchedFile = values.filesTouchedFile
             ? (path.isAbsolute(values.filesTouchedFile) ? values.filesTouchedFile : path.join(root, values.filesTouchedFile))
@@ -636,14 +696,21 @@ export function runHandoffFinalize(args, context) {
             }
             safePaths.push(relative);
         }
-        const companies = touchedCompanyPaths(safePaths);
+        const sessionCompany = boundSessionCompany(root);
+        const companyDirectory = sessionCompany
+            ? fs.statSync(path.join(root, "companies", sessionCompany), { throwIfNoEntry: false })
+            : undefined;
+        const companies = [...new Set([
+                ...touchedCompanyPaths(safePaths),
+                ...(companyDirectory?.isDirectory() ? [sessionCompany] : []),
+            ])].sort();
         const dirty = probe.hasGit && printGitStatus(root) !== "";
         const branchResult = probe.hasGit ? git(["symbolic-ref", "--short", "HEAD"], root) : { code: 1, stdout: "", stderr: "" };
         const commitResult = probe.hasGit ? git(["rev-parse", "--short", "HEAD"], root) : { code: 1, stdout: "", stderr: "" };
         const branch = branchResult.code === 0 ? branchResult.stdout.trim() : "DETACHED";
         const startCommit = commitResult.code === 0 ? commitResult.stdout.trim() : "unknown";
         const status = statusSummary(root, touchedFile);
-        const stepsInput = JSON.parse(values.nextSteps);
+        const stepsInput = parseHandoffJson(values.nextSteps, "--next-steps-json");
         const nextSteps = Array.isArray(stepsInput) ? stepsInput.map((raw, index) => {
             const step = typeof raw === "string" ? { step: raw } : isRecord(raw) ? { ...raw } : {};
             if (!jqTruthy(step.id))
@@ -666,8 +733,8 @@ export function runHandoffFinalize(args, context) {
             conversation_summary: values.summary,
             next_steps: nextSteps,
             files_touched: touchedValue,
-            learnings: JSON.parse(values.learnings),
-            metadata: { title: values.title, tags: JSON.parse(values.tags), company: companies },
+            learnings: parseHandoffJson(values.learnings, "--learnings-json"),
+            metadata: { title: values.title, tags: parseHandoffJson(values.tags, "--tags-json"), company: companies },
         };
         fs.mkdirSync(threadsDir, { recursive: true });
         fs.writeFileSync(path.join(root, threadPath), prettyJson(thread));
@@ -823,6 +890,9 @@ export function runHandoffFinalize(args, context) {
         return { code: 0, stdout, stderr: stderrParts.join("") };
     }
     catch (error) {
+        if (error instanceof HandoffJsonOptionError) {
+            return { code: 2, stdout: "", stderr: `handoff-finalize: invalid JSON for ${error.flag}: ${error.message}\n` };
+        }
         const message = error instanceof Error ? error.message : String(error);
         return { code: 1, stdout: "", stderr: `${message}\n` };
     }
@@ -891,7 +961,7 @@ function readThreadCompanyNames(file) {
         if (!jqTruthy(value))
             return [];
         const values = Array.isArray(value) ? value : [value];
-        return values.map((item) => typeof item === "string" ? item : compactJson(item).trimEnd());
+        return [...new Set(values.filter((item) => typeof item === "string" && /^[a-z][a-z0-9_-]*$/.test(item)))].sort();
     }
     catch {
         return [];
@@ -927,17 +997,7 @@ function workMeshSessionEnd(root) {
         return "work-mesh-session-end: skipped (hook disabled)";
     if (/(^|,)(work-mesh|work-mesh-live|\*)(,|$)/.test(`,${process.env.HQ_DISABLED_HOOKS ?? ""},`))
         return "work-mesh-session-end: skipped (hook disabled)";
-    let sessionId = "";
-    const current = path.join(root, "workspace/sessions/.current");
-    if (fs.existsSync(current)) {
-        try {
-            sessionId = fs.readFileSync(current, "utf8").replace(/\s/g, "");
-        }
-        catch {
-            sessionId = "";
-        }
-    }
-    sessionId = sessionId || process.env.CLAUDE_SESSION_ID || process.env.CODEX_SESSION_ID || process.env.CODEX_THREAD_ID || "";
+    const sessionId = resolveSessionId(root);
     if (!sessionId)
         return undefined;
     let harness = process.env.HQ_HARNESS || process.env.HQ_WORK_MESH_HARNESS || process.env.HQ_CHECKPOINT_RUNTIME || "claude-code";
@@ -1112,11 +1172,80 @@ export function runHandoffPostWorker(args, context) {
     else
         log("document-release: skipped (no thread path)");
     if (threadFile && fs.existsSync(threadFile) && commandAvailable("hq")) {
-        for (const company of readThreadCompanyNames(threadFile)) {
-            if (!/^[a-z][a-z0-9_-]*$/.test(company))
-                continue;
+        let syncCompanies = readThreadCompanyNames(threadFile);
+        const sessionCompany = boundSessionCompany(root);
+        if (sessionCompany) {
+            const updatedCompanies = [...new Set([...syncCompanies, sessionCompany])].sort();
+            const companyListChanged = JSON.stringify(syncCompanies) !== JSON.stringify(updatedCompanies);
+            syncCompanies = updatedCompanies;
+            if (companyListChanged) {
+                try {
+                    const thread = JSON.parse(fs.readFileSync(threadFile, "utf8"));
+                    if (!isRecord(thread))
+                        throw new Error("thread is not an object");
+                    let metadata;
+                    if (thread.metadata === null || thread.metadata === undefined)
+                        metadata = {};
+                    else if (isRecord(thread.metadata))
+                        metadata = thread.metadata;
+                    else
+                        throw new Error("thread metadata is not an object");
+                    metadata.company = syncCompanies;
+                    thread.metadata = metadata;
+                    const temporaryThread = path.join(path.dirname(threadFile), `.handoff-post-${process.pid}-${Math.random().toString(36).slice(2)}`);
+                    let temporaryFd;
+                    try {
+                        temporaryFd = fs.openSync(temporaryThread, "wx", 0o600);
+                        fs.writeFileSync(temporaryFd, `${compactJson(thread).trimEnd()}\n`);
+                        fs.closeSync(temporaryFd);
+                        temporaryFd = undefined;
+                        fs.chmodSync(temporaryThread, 0o600);
+                        fs.renameSync(temporaryThread, threadFile);
+                    }
+                    catch (error) {
+                        if (temporaryFd !== undefined) {
+                            try {
+                                fs.closeSync(temporaryFd);
+                            }
+                            catch { /* temporary output cleanup remains best effort */ }
+                        }
+                        try {
+                            fs.rmSync(temporaryThread, { force: true });
+                        }
+                        catch { /* jq/mv cleanup is fail-soft */ }
+                        throw error;
+                    }
+                }
+                catch {
+                    log("workspace-sync: skipped (could not add bound company to handoff thread)");
+                    syncCompanies = [];
+                }
+            }
+        }
+        let threadId = "";
+        let threadMirrorable = false;
+        try {
+            const thread = JSON.parse(fs.readFileSync(threadFile, "utf8"));
+            threadId = isRecord(thread) && typeof thread.thread_id === "string" ? thread.thread_id : "";
+            const relative = path.relative(root, threadFile);
+            threadMirrorable = /^workspace[\\/]threads[\\/]T-[A-Za-z0-9._-]+\.json$/.test(relative)
+                && /^T-[A-Za-z0-9._-]+$/.test(threadId);
+        }
+        catch { /* shell helper treats an invalid thread as non-mirrorable */ }
+        if (threadMirrorable && syncCompanies.length > 0) {
+            const mirrorHook = path.join(root, ".claude/hooks/mirror-thread-to-company.sh");
+            if (fs.existsSync(mirrorHook))
+                mirrorThread(root, threadFile);
+            else
+                log("workspace-sync: mirror hook unavailable for handoff thread");
+        }
+        for (const company of syncCompanies) {
             if (!fs.existsSync(path.join(root, "companies", company, "workspace")))
                 continue;
+            if (!threadMirrorable || !fs.existsSync(path.join(root, "companies", company, "workspace/sessions", `${threadId}.json`))) {
+                log(`workspace-sync: skipped (thread mirror missing for ${company})`);
+                continue;
+            }
             const pushed = spawnSync("hq", ["sync", "push", "--company", company, `companies/${company}/workspace`], {
                 cwd: root,
                 env: process.env,

package/dist/commands/core-jobs-native.d.ts

@@ -3,6 +3,21 @@ import { Command } from "commander";
 export declare function detectHostTimezone(override: string, resolveLocaltime?: (file: string) => string, readTimedatectl?: () => string): string;
 export declare function runScheduleParse(argv: string[]): number;
 export declare function validateJobs(args: string[]): number;
+type ReconcileCommandResult = {
+    status: number;
+    stdout: string;
+    stderr: string;
+};
+export type ReconcileRunner = (command: string, args: string[]) => ReconcileCommandResult;
+export type ReconcileOptions = {
+    schedulerRunner?: ReconcileRunner;
+    commandRunner?: ReconcileRunner;
+    identityFileReader?: (file: string) => string | undefined;
+    fetcher?: typeof fetch;
+    now?: () => Date;
+};
+export declare function runReconcile(argv: string[], rootArg?: string, options?: ReconcileOptions): Promise<number>;
 export declare function registerCoreJobsNativeCommand(core: Command): void;
 export declare function rawArgumentsForCommand(command: Command, fallback: string[], raw?: string[]): string[];
+export {};
 //# sourceMappingURL=core-jobs-native.d.ts.map