@indigoai-us/hq-cli 5.345.135 → 5.345.137

package/dist/commands/meetings.js

@@ -251,26 +251,69 @@ function renderSignals(signals) {
     }
     console.log();
 }
+/** The server caps one `/v1/meetings` page at this many rows. */
+const MEETINGS_PAGE_SIZE = "100";
+/** Upper bound on list pages one short-id lookup reads (per cursor chain). */
+export const SHORT_ID_MAX_PAGES = 50;
+/**
+ * Resolve the 8-character id `hq meetings list` prints to a full meeting id.
+ *
+ * `/v1/meetings` is paged: the server caps a page at 100 rows (it ignores a
+ * larger `limit`) and may end a page early, even empty, with
+ * `truncated: true` when it runs out of time. Reading only the first page
+ * missed any meeting past it, so follow `nextToken` (and `nativeNextToken`
+ * for HQ Meet calls) until the prefix is found or the list ends. A full
+ * 8-character prefix stops at the first page with a match; a shorter prefix
+ * reads every page so ambiguity is still reported.
+ */
 async function resolveShortId(token, prefix, query) {
     if (prefix.includes("-") && prefix.length > 8)
         return prefix;
-    const res = await vaultApiFetch({
-        token,
-        path: "/v1/meetings",
-        query: { ...query, limit: "500" },
-    });
-    if (!res.ok) {
-        throw new Error(`Could not resolve meeting ID "${prefix}" — failed to list meetings (${res.status}). Pass the full meeting id.`);
+    const stopOnFirstMatch = prefix.length >= 8;
+    const matches = new Map();
+    let capped = false;
+    const fetchPage = async (extra) => {
+        const res = await vaultApiFetch({
+            token,
+            path: "/v1/meetings",
+            query: { ...query, limit: MEETINGS_PAGE_SIZE, ...extra },
+        });
+        if (!res.ok) {
+            throw new Error(`Could not resolve meeting ID "${prefix}" — failed to list meetings (${res.status}). Pass the full meeting id.`);
+        }
+        const data = (await res.json());
+        for (const m of data.meetings ?? []) {
+            if (typeof m.meetingId === "string" && m.meetingId.startsWith(prefix))
+                matches.set(m.meetingId, m);
+        }
+        return data;
+    };
+    const first = await fetchPage({});
+    let nextToken = first.nextToken;
+    for (let page = 1; nextToken && !(stopOnFirstMatch && matches.size > 0); page += 1) {
+        if (page >= SHORT_ID_MAX_PAGES) {
+            capped = true;
+            break;
+        }
+        nextToken = (await fetchPage({ nextToken })).nextToken;
+    }
+    let nativeCursor = first.nativeNextToken;
+    for (let page = 1; nativeCursor && !(stopOnFirstMatch && matches.size > 0); page += 1) {
+        if (page >= SHORT_ID_MAX_PAGES) {
+            capped = true;
+            break;
+        }
+        nativeCursor = (await fetchPage({ nativeCursor })).nativeNextToken;
     }
-    const data = (await res.json());
-    const matches = data.meetings.filter((m) => m.meetingId.startsWith(prefix));
-    if (matches.length === 1)
-        return matches[0].meetingId;
-    if (matches.length > 1) {
-        console.error(chalk.red(`Ambiguous ID prefix "${prefix}" — matches ${matches.length} meetings. Use a longer prefix.`));
+    if (matches.size === 1)
+        return [...matches.keys()][0];
+    if (matches.size > 1) {
+        console.error(chalk.red(`Ambiguous ID prefix "${prefix}" — matches ${matches.size} meetings. Use a longer prefix.`));
         process.exit(1);
     }
-    console.error(chalk.red(`No meeting matches ID "${prefix}". It may be older than the meetings shown by \`hq meetings list\`, still processing, or attributed to a different company. Pass the full meeting id, add --company <slug>, or widen the list with \`hq meetings list --limit <n>\`.`));
+    console.error(chalk.red(capped
+        ? `No meeting matches ID "${prefix}" in the newest ${SHORT_ID_MAX_PAGES * Number(MEETINGS_PAGE_SIZE)} meetings. Pass the full meeting id (shown by \`hq meetings list --json\`).`
+        : `No meeting matches ID "${prefix}". It may still be processing or attributed to a different company. Pass the full meeting id, or add --company <slug>.`));
     process.exit(1);
 }
 async function handleApiError(res, json = false) {

package/dist/commands/mesh.d.ts

@@ -6,10 +6,27 @@
  * Distinct from `hq doctor` (hook guardrails).
  */
 import { Command } from "commander";
-import { type MeshCompany, type MeshThread } from "../lib/mesh/api.js";
+import { type MeshCompany, type MeshProjectRepo, type MeshProjectStoryInput, type MeshThread } from "../lib/mesh/api.js";
+import { UnknownProjectStoryStateError } from "../lib/mesh/story-status.js";
 import { type DaemonInstallPlatform, type InstallPaths } from "../lib/mesh/live/daemon/install.js";
 import { type RunCommand } from "../lib/service-manager/launchd.js";
 export declare function formatCheckLines(threads: MeshThread[], company: MeshCompany, projectId?: string): string[];
+/** 400 PROJECT_VIEW_INVALID "Unknown story ..." from a story PATCH. */
+export declare function isUnknownBoardStory(error: unknown): boolean;
+/** The local PRD for this project when it lists `storyId`; null otherwise. */
+export declare function localPrdWithStory(company: {
+    companySlug?: string;
+}, projectId: string, storyId: string, hqRoot?: string | undefined): {
+    prdPath: string;
+    source: ProjectPlanSource;
+} | null;
+type ProjectPlanSource = {
+    name?: string;
+    description?: string;
+    stories: MeshProjectStoryInput[];
+    repos?: MeshProjectRepo[];
+    rejectedStories: UnknownProjectStoryStateError[];
+};
 /** Test seam for the usage-attribution question asked by `default set`. */
 export interface DefaultCompanyPromptDeps {
     /** True when stdin and stdout are a terminal (a person can answer). */
@@ -61,4 +78,5 @@ export declare function runDaemonStatus(opts: {
     run?: RunCommand;
     uid?: number;
 }): Promise<void>;
+export {};
 //# sourceMappingURL=mesh.d.ts.map

package/dist/commands/mesh.js

@@ -174,6 +174,42 @@ async function requireAssignableSelf(token, verb) {
     }
     return resolved;
 }
+/** 400 PROJECT_VIEW_INVALID "Unknown story ..." from a story PATCH. */
+export function isUnknownBoardStory(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const candidate = error;
+    return (httpStatus(error) === 400 &&
+        (candidate.code === "PROJECT_VIEW_INVALID" ||
+            (typeof candidate.message === "string" && candidate.message.includes("PROJECT_VIEW_INVALID"))) &&
+        typeof candidate.message === "string" &&
+        candidate.message.includes("Unknown story"));
+}
+/** The local PRD for this project when it lists `storyId`; null otherwise. */
+export function localPrdWithStory(company, projectId, storyId, hqRoot = process.env.HQ_ROOT?.trim() || findHqRoot() || undefined) {
+    const prdPath = findLocalPrd(hqRoot, company.companySlug, projectId);
+    if (!prdPath)
+        return null;
+    let source;
+    try {
+        source = parseProjectPlan(readFileSync(prdPath, "utf8"), prdPath, { requireUserStories: true });
+    }
+    catch {
+        return null;
+    }
+    return source.stories.some((story) => story.id === storyId) ? { prdPath, source } : null;
+}
+function unknownStoryHint(error, company, projectId, storyId, prdPath) {
+    const base = error instanceof Error ? error.message : String(error);
+    const command = `hq mesh project ensure ${projectId} --company ${company.companySlug ?? company.companyUid} --stories-file ${prdPath ?? "<prd.json>"}`;
+    const hint = prdPath
+        ? `${storyId} is in ${prdPath} but not on the Board. Register it with: ${command}`
+        : `${storyId} is not on the ${projectId} Board. Add it to the project PRD, then run: ${command}`;
+    return Object.assign(new Error(`${base}\n${hint}`), {
+        status: httpStatus(error),
+        code: error?.code,
+    });
+}
 async function runStory(opts) {
     const storyId = opts.story?.trim();
     const status = opts.status?.trim();
@@ -203,14 +239,46 @@ async function runStory(opts) {
         }
         assigneeUid = assignee;
     }
+    const patch = {
+        ...(status ? { status } : {}),
+        ...(assigneeUid ? { assigneeUid } : {}),
+        ...(clearAssignee ? { clearAssignee: true } : {}),
+        ...(opts.force ? { force: true } : {}),
+    };
     let patched;
+    let registeredFrom;
     try {
-        patched = await patchStory(token, company.companyUid, projectId, storyId, {
-            ...(status ? { status } : {}),
-            ...(assigneeUid ? { assigneeUid } : {}),
-            ...(clearAssignee ? { clearAssignee: true } : {}),
-            ...(opts.force ? { force: true } : {}),
-        });
+        try {
+            patched = await patchStory(token, company.companyUid, projectId, storyId, patch);
+        }
+        catch (err) {
+            if (!isUnknownBoardStory(err))
+                throw err;
+            // The story is in the local PRD but not on the Board yet: register the
+            // PRD (the same merge `hq mesh project ensure` does), then retry once.
+            const recovery = localPrdWithStory(company, projectId, storyId);
+            if (!recovery)
+                throw unknownStoryHint(err, company, projectId, storyId);
+            if (opts.ensure === false) {
+                throw unknownStoryHint(err, company, projectId, storyId, recovery.prdPath);
+            }
+            await ensureProjectFromSource({
+                token,
+                company,
+                projectId,
+                source: recovery.source,
+                current: await getProjectView(token, company.companyUid, projectId).catch((viewErr) => {
+                    if (httpStatus(viewErr) === 404)
+                        return undefined;
+                    throw viewErr;
+                }),
+            });
+            registeredFrom = recovery.prdPath;
+            if (!opts.json) {
+                console.error(`Work mesh: ${storyId} was not on the ${projectId} Board; registered the project from ${recovery.prdPath}.`);
+            }
+            patched = await patchStory(token, company.companyUid, projectId, storyId, patch);
+        }
     }
     catch (err) {
         const conflict = storyConflictFromError(err);
@@ -219,7 +287,14 @@ async function runStory(opts) {
         throw err;
     }
     if (opts.json) {
-        console.log(JSON.stringify({ ok: true, action: "story", company, ...patched, storyId }, null, 2));
+        console.log(JSON.stringify({
+            ok: true,
+            action: "story",
+            company,
+            ...patched,
+            storyId,
+            ...(registeredFrom ? { registeredFrom } : {}),
+        }, null, 2));
         return;
     }
     const assignment = assignee === "none"
@@ -590,67 +665,13 @@ async function runProjectMemberAdd(projectId, personUid, opts) {
         ? `Work mesh: added ${personUid} to project ${projectId}`
         : `Work mesh: ${personUid} is already a member of project ${projectId}`);
 }
-async function runProjectEnsure(projectId, opts) {
-    if (!opts.storiesFile?.trim())
-        fail("`--stories-file <prd.json>` is required.");
-    let source;
-    try {
-        source = parseProjectPlan(readFileSync(opts.storiesFile, "utf8"), opts.storiesFile, { requireUserStories: true });
-    }
-    catch (err) {
-        if (!(err instanceof RejectedProjectStoryStatesError) || !opts.json)
-            throw err;
-        failProjectStoryStates(err.rejected, true);
-        return;
-    }
-    const { token, company } = await withCompany(opts);
-    let current;
-    try {
-        current = await getProjectView(token, company.companyUid, projectId);
-    }
-    catch (err) {
-        if (httpStatus(err) !== 404)
-            throw err;
-    }
-    if (opts.dryRun) {
-        if (current && (current.companyUid !== company.companyUid || current.projectId !== projectId)) {
-            fail("Work mesh project ensure dry-run: Board company or project id did not match the request.");
-        }
-        const stories = current ? mergeProjectStories(current.stories, source.stories) : source.stories;
-        const sourceStatuses = source.stories.map((story) => ({
-            id: story.id,
-            title: story.title,
-            status: boardStoryStatus(story),
-        }));
-        const boardStatuses = stories.map((story) => ({
-            id: story.id,
-            title: story.title,
-            status: boardStoryStatus(story),
-        }));
-        if (opts.json) {
-            console.log(JSON.stringify({
-                ok: source.rejectedStories.length === 0,
-                action: "project.ensure.dry-run",
-                projectId,
-                companyUid: company.companyUid,
-                sourceStatuses,
-                stories: boardStatuses,
-                ...(source.rejectedStories.length ? { errors: projectStateErrors(source.rejectedStories) } : {}),
-            }, null, 2));
-        }
-        else {
-            console.log(`Work mesh: project ${projectId} dry run (${sourceStatuses.length} source stories)`);
-            console.log("Source statuses:");
-            for (const story of sourceStatuses)
-                console.log(`${story.id}\t${story.status}`);
-            console.log("Merged Board statuses:");
-            for (const story of boardStatuses)
-                console.log(`${story.id}\t${story.status}`);
-        }
-        if (source.rejectedStories.length)
-            process.exitCode = 1;
-        return;
-    }
+/**
+ * Create or merge the project Board view from a parsed PRD, register the
+ * project, and verify every PRD story and repo is on the Board. Shared by
+ * `hq mesh project ensure` and the `hq mesh story` unknown-story recovery.
+ */
+async function ensureProjectFromSource(input) {
+    const { token, company, projectId, source, current } = input;
     // Genesis thread, then the view, then register. Register returns 403
     // PROJECT_NOT_IN_COMPANY until both exist. A missing view uses that chain
     // from ensureProjectBoard; an existing view is merged, then registered.
@@ -726,12 +747,78 @@ async function runProjectEnsure(projectId, opts) {
     if (verified.version === undefined) {
         fail("Work mesh project ensure: verified view has no version.");
     }
-    const payload = {
+    return {
         projectId: verified.projectId,
         threadId: registration.threadId,
         channelId: registration.channelId,
         version: verified.version,
         stories: verified.stories,
+    };
+}
+async function runProjectEnsure(projectId, opts) {
+    if (!opts.storiesFile?.trim())
+        fail("`--stories-file <prd.json>` is required.");
+    let source;
+    try {
+        source = parseProjectPlan(readFileSync(opts.storiesFile, "utf8"), opts.storiesFile, { requireUserStories: true });
+    }
+    catch (err) {
+        if (!(err instanceof RejectedProjectStoryStatesError) || !opts.json)
+            throw err;
+        failProjectStoryStates(err.rejected, true);
+        return;
+    }
+    const { token, company } = await withCompany(opts);
+    let current;
+    try {
+        current = await getProjectView(token, company.companyUid, projectId);
+    }
+    catch (err) {
+        if (httpStatus(err) !== 404)
+            throw err;
+    }
+    if (opts.dryRun) {
+        if (current && (current.companyUid !== company.companyUid || current.projectId !== projectId)) {
+            fail("Work mesh project ensure dry-run: Board company or project id did not match the request.");
+        }
+        const stories = current ? mergeProjectStories(current.stories, source.stories) : source.stories;
+        const sourceStatuses = source.stories.map((story) => ({
+            id: story.id,
+            title: story.title,
+            status: boardStoryStatus(story),
+        }));
+        const boardStatuses = stories.map((story) => ({
+            id: story.id,
+            title: story.title,
+            status: boardStoryStatus(story),
+        }));
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: source.rejectedStories.length === 0,
+                action: "project.ensure.dry-run",
+                projectId,
+                companyUid: company.companyUid,
+                sourceStatuses,
+                stories: boardStatuses,
+                ...(source.rejectedStories.length ? { errors: projectStateErrors(source.rejectedStories) } : {}),
+            }, null, 2));
+        }
+        else {
+            console.log(`Work mesh: project ${projectId} dry run (${sourceStatuses.length} source stories)`);
+            console.log("Source statuses:");
+            for (const story of sourceStatuses)
+                console.log(`${story.id}\t${story.status}`);
+            console.log("Merged Board statuses:");
+            for (const story of boardStatuses)
+                console.log(`${story.id}\t${story.status}`);
+        }
+        if (source.rejectedStories.length)
+            process.exitCode = 1;
+        return;
+    }
+    const ensured = await ensureProjectFromSource({ token, company, projectId, source, current });
+    const payload = {
+        ...ensured,
         ...(source.rejectedStories.length ? { ok: false, errors: projectStateErrors(source.rejectedStories) } : {}),
     };
     noteCallingSessionBound(payload.projectId, company);
@@ -2520,7 +2607,8 @@ export function registerMeshCommand(program, deps = {}) {
         .requiredOption("--story <id>", "Story id, e.g. US-001")
         .option("--status <status>", "queued|in_progress|review|done")
         .option("--assignee <uid|me|none>", "Assign a person or agent uid, yourself, or clear")
-        .option("--force", "Override another holder's assignment")).action((opts) => wrap(() => runStory(opts))());
+        .option("--force", "Override another holder's assignment")
+        .option("--no-ensure", "Do not register the project from its local prd.json when the story is not on the Board")).action((opts) => wrap(() => runStory(opts))());
     addSharedFlags(mesh
         .command("claim")
         .description("Assign a story to yourself and move it to in_progress")

package/dist/commands/reindex.js

@@ -33,6 +33,7 @@ import { reindex, rescue } from '@indigoai-us/hq-cloud';
 import { trustHqRuntimeHooks } from '../utils/hook-trust.js';
 import { findHqRoot } from '../utils/manifest.js';
 import { guardLargeFiles } from '../utils/large-file-guard.js';
+import { liveProcessCwds, recentTranscriptCwds, sessionOwnerReason, } from '../lib/core-utils/worktree-session-owner.js';
 const HOOK_EVENTS = ['SessionStart', 'UserPromptSubmit', 'PreToolUse'];
 const BYPASS_MODE = 'bypassPermissions';
 const HOOK_CHECK_RELATIVE_PATH = path.join('core', 'scripts', 'check-hq-hooks.sh');
@@ -296,6 +297,34 @@ function hasRecentWorktreeActivity(worktree, gitDir, cutoff, deadline = Number.P
     });
     return latestContentChange(dirtyPaths) >= cutoff;
 }
+/**
+ * Why removing this worktree could lose work, or undefined when it is clean
+ * and every commit on HEAD is on its upstream and on a remote. A Git failure
+ * (including a deadline hit) is a reason too, so the worktree is retained.
+ */
+function unpreservedWorkReason(worktree, deadline) {
+    const status = runGit(worktree, ['status', '--porcelain', '--untracked-files=all', '--ignored=no'], deadline);
+    if (status?.status !== 0)
+        return 'git-error';
+    if (status.stdout.trim() !== '')
+        return 'dirty';
+    const upstream = runGit(worktree, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], deadline);
+    if (upstream === undefined)
+        return 'git-error';
+    if (upstream.status !== 0 || !upstream.stdout.trim())
+        return 'no-upstream';
+    const ahead = runGit(worktree, ['rev-list', '--count', '@{u}..HEAD'], deadline);
+    if (ahead?.status !== 0)
+        return 'git-error';
+    if (ahead.stdout.trim() !== '0')
+        return 'unpushed';
+    const offRemote = runGit(worktree, ['rev-list', '--count', 'HEAD', '--not', '--remotes'], deadline);
+    if (offRemote?.status !== 0)
+        return 'git-error';
+    if (offRemote.stdout.trim() !== '0')
+        return 'unpushed';
+    return undefined;
+}
 /**
  * Remove inactive worktrees created by `hq worktree` without ever deleting
  * directories directly. This runs on the hook path, so it uses a shallow
@@ -305,6 +334,11 @@ export function removeStaleHqWorktrees(hqRoot, now = Date.now(), deadline = Numb
     if (!isHqRoot(hqRoot))
         return;
     const cutoff = now - WORKTREE_STALE_AFTER_MS;
+    const kept = (worktree, reason) => {
+        console.log(`reindex: kept stale worktree ${worktree} (${reason})`);
+    };
+    // Pass 1: cheap local checks. Only clean, pushed, idle worktrees go on.
+    const eligible = [];
     for (const worktree of managedWorktreeCandidates(hqRoot)) {
         if (Date.now() >= deadline)
             break;
@@ -313,18 +347,59 @@ export function removeStaleHqWorktrees(hqRoot, now = Date.now(), deadline = Numb
         const gitDir = linkedWorktreeGitDir(worktree, deadline);
         if (!gitDir || hasRecentWorktreeActivity(worktree, gitDir, cutoff, deadline))
             continue;
+        const unsafe = unpreservedWorkReason(worktree, deadline);
+        if (unsafe) {
+            kept(worktree, unsafe);
+            continue;
+        }
+        eligible.push(worktree);
+    }
+    if (eligible.length === 0)
+        return;
+    // Pass 2: session ownership. A session working in the worktree may have no
+    // process parked there between tool calls, so recent transcripts count too.
+    // A probe that cannot finish inside the budget retains everything.
+    const processCwds = liveProcessCwds(Math.max(1, Math.min(WORKTREE_GIT_TIMEOUT_MS, deadline - Date.now())));
+    const transcriptCwds = processCwds === undefined
+        ? undefined
+        : recentTranscriptCwds({ nowMs: now, deadline });
+    if (processCwds === undefined || transcriptCwds === undefined) {
+        for (const worktree of eligible)
+            kept(worktree, 'session-check-incomplete');
+        return;
+    }
+    for (const worktree of eligible) {
+        if (Date.now() >= deadline)
+            break;
+        let real = worktree;
+        try {
+            real = fs.realpathSync(worktree);
+        }
+        catch { /* compare the literal spelling */ }
+        const owner = sessionOwnerReason(processCwds, transcriptCwds, worktree, real);
+        if (owner) {
+            kept(worktree, owner);
+            continue;
+        }
         // Narrow the destructive TOCTOU window: re-resolve the linked-worktree
-        // identity and re-measure activity immediately before asking Git to remove
-        // it. Git remains the only component that deletes the directory.
+        // identity and re-measure activity and preservation immediately before
+        // asking Git to remove it. Git remains the only component that deletes the
+        // directory.
         const confirmedGitDir = linkedWorktreeGitDir(worktree, deadline);
         if (!confirmedGitDir || hasRecentWorktreeActivity(worktree, confirmedGitDir, cutoff, deadline))
             continue;
+        const confirmedUnsafe = unpreservedWorkReason(worktree, deadline);
+        if (confirmedUnsafe) {
+            kept(worktree, confirmedUnsafe);
+            continue;
+        }
         // Recursive removal is not transactional. Only start it inside the sweep
         // budget, then let Git finish so a timeout cannot leave a registered,
-        // partially deleted worktree behind.
-        const removal = runGit(worktree, ['worktree', 'remove', '--force', worktree], deadline, true);
+        // partially deleted worktree behind. No --force: Git itself refuses a
+        // worktree that gained changes since the checks above.
+        const removal = runGit(worktree, ['worktree', 'remove', worktree], deadline, true);
         if (removal?.status === 0) {
-            console.log(`reindex: removed stale worktree ${worktree} (branch preserved; stale uncommitted files are not recoverable)`);
+            console.log(`reindex: removed stale worktree ${worktree} (clean and pushed; branch kept)`);
             continue;
         }
         const reason = removal?.stderr.trim() || removal?.stdout.trim() || 'Git could not remove it';