@indigoai-us/hq-cli 5.87.0 → 5.88.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [5.88.0]
+
+### Changed
+
+- Replaced the ten bundled `rebuild-*-index.sh` assets behind
+  `hq core rebuild-index <target>` with native, tested TypeScript renderers.
+  The command surface and scaffold-only assets remain unchanged, while rebuilds
+  no longer depend on bundled scaffold assets being present. (#311)
+
 ## [5.87.0]
 
 ### Added

package/dist/commands/core.d.ts

@@ -29,6 +29,7 @@
  * `ScaffoldRoot`.
  */
 import { Command } from "commander";
+import { type IndexTarget } from "../lib/index-render/index.js";
 /**
  * Which tree a scaffold script operates on, mirroring how the ORIGINAL script
  * found its root before it moved. Getting this wrong is not cosmetic: injecting a
@@ -64,9 +65,13 @@ export type ScaffoldCommand = ScaffoldAsset & {
     /** Direct subcommand name — `hq core <name>`. */
     name: string;
 };
-export type RebuildIndexTarget = ScaffoldAsset & {
+export type RebuildIndexTarget = {
     /** Rebuild target — `hq core rebuild-index <target>`. */
     target: string;
+    /** Native renderer identifier. */
+    renderer: IndexTarget;
+    /** One-line summary, shown in `hq core --help`. */
+    summary: string;
 };
 export type WorkerSubcommand = ScaffoldAsset & {
     /** Subcommand name under the `worker` group — `hq core worker <name>`. */
@@ -86,7 +91,7 @@ export declare const WORKER_SUBCOMMANDS: WorkerSubcommand[];
 /**
  * The ten index rebuild targets. The command registration below intentionally
  * loops over this table for lookup, so adding a target never requires another
- * action handler and every target retains its own bundled asset.
+ * action handler and every target retains its own native renderer.
  */
 export declare const REBUILD_INDEX_TARGETS: RebuildIndexTarget[];
 /**
@@ -98,7 +103,13 @@ export declare const REBUILD_INDEX_TARGETS: RebuildIndexTarget[];
  * would make the forwarders harder to audit against this table.
  */
 export declare const SCAFFOLD_COMMANDS: ScaffoldCommand[];
-/** Every bundled asset, used by packaging and interpreter tests. */
+/**
+ * Bundled solely for HQ-root scaffolds, which still need these as loose files.
+ * `rebuild-index` dispatches them natively since this change, so none has a
+ * direct `hq core` command.
+ */
+export declare const SCAFFOLD_ONLY_ASSETS: ScaffoldAsset[];
+/** Every claimed bundled asset, used by packaging and interpreter tests. */
 export declare const SCAFFOLD_ASSETS: ScaffoldAsset[];
 export declare function registerCoreCommands(program: Command): Command;
 export {};

package/dist/commands/core.js

@@ -32,6 +32,7 @@ import { Option } from "commander";
 import { registerCoreCheckpointCommand } from "./core-checkpoint.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { runBundledScript } from "../utils/run-bundled-script.js";
+import { renderIndexTarget } from "../lib/index-render/index.js";
 /**
  * The `hq core worker <name>` subgroup — worker-scoped skill maintenance.
  *
@@ -59,67 +60,57 @@ export const WORKER_SUBCOMMANDS = [
 /**
  * The ten index rebuild targets. The command registration below intentionally
  * loops over this table for lookup, so adding a target never requires another
- * action handler and every target retains its own bundled asset.
+ * action handler and every target retains its own native renderer.
  */
 export const REBUILD_INDEX_TARGETS = [
     {
         target: "all",
-        asset: "core/scripts/rebuild-all-indexes.sh",
-        root: "live",
+        renderer: "all",
         summary: "Regenerate every INDEX.md across the HQ tree",
     },
     {
         target: "companies",
-        asset: "core/scripts/rebuild-companies-index.sh",
-        root: "live",
+        renderer: "companies",
         summary: "Regenerate companies/INDEX.md",
     },
     {
         target: "company-knowledge",
-        asset: "core/scripts/rebuild-company-knowledge-index.sh",
-        root: "live",
+        renderer: "company-knowledge",
         summary: "Regenerate a company's knowledge INDEX.md",
     },
     {
         target: "orchestrator",
-        asset: "core/scripts/rebuild-orchestrator-index.sh",
-        root: "live",
+        renderer: "orchestrator",
         summary: "Regenerate the orchestrator workspace INDEX.md",
     },
     {
         target: "projects",
-        asset: "core/scripts/rebuild-projects-index.sh",
-        root: "live",
+        renderer: "projects",
         summary: "Regenerate the projects INDEX.md",
     },
     {
         target: "public-knowledge",
-        asset: "core/scripts/rebuild-public-knowledge-index.sh",
-        root: "live",
+        renderer: "public-knowledge",
         summary: "Regenerate core/knowledge/public/INDEX.md",
     },
     {
         target: "reports",
-        asset: "core/scripts/rebuild-reports-index.sh",
-        root: "live",
+        renderer: "reports",
         summary: "Regenerate the reports INDEX.md",
     },
     {
         target: "social-drafts",
-        asset: "core/scripts/rebuild-social-drafts-index.sh",
-        root: "live",
+        renderer: "social-drafts",
         summary: "Regenerate workspace/social-drafts/INDEX.md",
     },
     {
         target: "threads",
-        asset: "core/scripts/rebuild-threads-index.sh",
-        root: "live",
+        renderer: "threads",
         summary: "Regenerate the session-threads INDEX.md",
     },
     {
         target: "workers",
-        asset: "core/scripts/rebuild-workers-index.sh",
-        root: "live",
+        renderer: "workers",
         summary: "Regenerate the workers INDEX.md",
     },
 ];
@@ -201,10 +192,67 @@ export const SCAFFOLD_COMMANDS = [
         summary: "Create a git worktree under workspace/worktrees/",
     },
 ];
-/** Every bundled asset, used by packaging and interpreter tests. */
+/**
+ * Bundled solely for HQ-root scaffolds, which still need these as loose files.
+ * `rebuild-index` dispatches them natively since this change, so none has a
+ * direct `hq core` command.
+ */
+export const SCAFFOLD_ONLY_ASSETS = [
+    {
+        asset: "core/scripts/rebuild-all-indexes.sh",
+        root: "cwd",
+        summary: "Scaffold-only native rebuild-index companion",
+    },
+    {
+        asset: "core/scripts/rebuild-companies-index.sh",
+        root: "cwd",
+        summary: "Scaffold-only native rebuild-index companion",
+    },
+    {
+        asset: "core/scripts/rebuild-company-knowledge-index.sh",
+        root: "cwd",
+        summary: "Scaffold-only native rebuild-index companion",
+    },
+    {
+        asset: "core/scripts/rebuild-orchestrator-index.sh",
+        root: "cwd",
+        summary: "Scaffold-only native rebuild-index companion",
+    },
+    {
+        asset: "core/scripts/rebuild-projects-index.sh",
+        root: "cwd",
+        summary: "Scaffold-only native rebuild-index companion",
+    },
+    {
+        asset: "core/scripts/rebuild-public-knowledge-index.sh",
+        root: "cwd",
+        summary: "Scaffold-only native rebuild-index companion",
+    },
+    {
+        asset: "core/scripts/rebuild-reports-index.sh",
+        root: "cwd",
+        summary: "Scaffold-only native rebuild-index companion",
+    },
+    {
+        asset: "core/scripts/rebuild-social-drafts-index.sh",
+        root: "cwd",
+        summary: "Scaffold-only native rebuild-index companion",
+    },
+    {
+        asset: "core/scripts/rebuild-threads-index.sh",
+        root: "cwd",
+        summary: "Scaffold-only native rebuild-index companion",
+    },
+    {
+        asset: "core/scripts/rebuild-workers-index.sh",
+        root: "cwd",
+        summary: "Scaffold-only native rebuild-index companion",
+    },
+];
+/** Every claimed bundled asset, used by packaging and interpreter tests. */
 export const SCAFFOLD_ASSETS = [
-    ...REBUILD_INDEX_TARGETS,
     ...SCAFFOLD_COMMANDS,
+    ...SCAFFOLD_ONLY_ASSETS,
     ...WORKER_SUBCOMMANDS,
 ];
 /**
@@ -307,7 +355,10 @@ export function registerCoreCommands(program) {
         if (!entry) {
             throw expectedUserError(`Unknown rebuild-index target "${target}". Valid targets: ${validTargets.join(", ")}.`);
         }
-        runCommand(entry, args, cmd, target);
+        const scope = core.opts();
+        const hqRoot = resolveLiveRoot({ hqRoot: scope.hqRoot });
+        const operands = cmd.args.length > 0 ? cmd.args : args;
+        renderIndexTarget(entry.renderer, { root: hqRoot, log: (message) => process.stderr.write(`${message}\n`) }, operands.slice(1));
     });
     for (const entry of SCAFFOLD_COMMANDS) {
         core

package/dist/lib/index-render/companies.d.ts

@@ -0,0 +1,3 @@
+import { RenderContext, RenderResult } from "./shared.js";
+export declare function renderCompanies(context: RenderContext): RenderResult;
+//# sourceMappingURL=companies.d.ts.map

package/dist/lib/index-render/companies.js

@@ -0,0 +1,57 @@
+import * as fs from "fs";
+import * as path from "path";
+import { basename, countImmediate, date, exists, immediateEntries, isHidden, log, projectStatus, readJson, sanitize, titleize, truncate, write } from "./shared.js";
+function description(root, company, name) {
+    const base = `companies/${company}/${name}`;
+    const nonHidden = (child) => !isHidden(child);
+    switch (name) {
+        case "data": return `${countImmediate(root, base, nonHidden)} item(s)`;
+        case "knowledge": return exists(root, `${base}/.git`) ? "Embedded git repo" : `Inline knowledge (${countImmediate(root, base, (n, f) => !isHidden(n) && fs.statSync(f).isDirectory())} subdirs)`;
+        case "settings": return `${countImmediate(root, base, (n, f) => !isHidden(n) && fs.statSync(f).isDirectory())} integration(s)`;
+        case "policies": return `${countImmediate(root, base, (n) => n.endsWith(".md"))} policy file(s)`;
+        case "projects": return `${countImmediate(root, base, (n, f) => !n.startsWith("_") && !isHidden(n) && fs.statSync(f).isDirectory())} project(s)`;
+        case "workers": return `${countImmediate(root, base, (n, f) => !isHidden(n) && fs.statSync(f).isDirectory())} worker(s)`;
+        case "repos": return `${countImmediate(root, base, (n, f) => { const s = fs.lstatSync(f); return !isHidden(n) && (s.isDirectory() || s.isSymbolicLink()); })} repo link(s)`;
+        case "registry": return `Resource registry (${countImmediate(root, `${base}/resources`, (n) => n.endsWith(".yaml"))} resource(s))`;
+        case "scripts": return `${countImmediate(root, base, (_n, f) => fs.statSync(f).isFile())} script(s)`;
+        default: return "—";
+    }
+}
+export function renderCompanies(context) {
+    const written = [];
+    for (const directory of immediateEntries(context.root, "companies", "dir")) {
+        const company = basename(directory);
+        if (company.startsWith("_") || isHidden(company))
+            continue;
+        const lines = [`# ${titleize(company)}`, "", `> Auto-generated. Updated: ${date(context.now)}`, "", "| Name | Description |", "|------|-------------|"];
+        for (const name of ["data", "knowledge", "policies", "projects", "registry", "repos", "scripts", "settings", "workers"]) {
+            if (exists(context.root, `companies/${company}/${name}`))
+                lines.push(`| \`${name}/\` | ${sanitize(description(context.root, company, name))} |`);
+        }
+        lines.push("", "## Projects", "");
+        const projects = `companies/${company}/projects`;
+        if (exists(context.root, projects)) {
+            lines.push("| Project | Status | Description |", "|---------|--------|-------------|");
+            for (const projectDirectory of immediateEntries(context.root, projects, "dir")) {
+                const project = basename(projectDirectory);
+                if (project.startsWith("_") || isHidden(project))
+                    continue;
+                const prd = path.join(projectDirectory, "prd.json");
+                const parsed = readJson(prd);
+                let text = typeof parsed?.description === "string" ? parsed.description : "";
+                text = truncate(sanitize(text), 110) || "—";
+                lines.push(`| \`${project}\` | ${projectStatus(context.root, project, prd, "active")} | ${text} |`);
+            }
+        }
+        else
+            lines.push("_No projects directory._");
+        lines.push("", "## Deployments", "", "_See `companies/manifest.yaml` for deployment targets._", "");
+        const output = `companies/${company}/INDEX.md`;
+        write(context, output, lines.join("\n"));
+        written.push(output);
+        log(context, `rebuild-companies-index: wrote ${output}`);
+    }
+    log(context, `rebuild-companies-index: regenerated ${written.length} company INDEX.md file(s)`);
+    return { written };
+}
+//# sourceMappingURL=companies.js.map

package/dist/lib/index-render/company-knowledge.d.ts

@@ -0,0 +1,3 @@
+import { RenderContext, RenderResult } from "./shared.js";
+export declare function renderCompanyKnowledge(context: RenderContext): RenderResult;
+//# sourceMappingURL=company-knowledge.d.ts.map

package/dist/lib/index-render/company-knowledge.js

@@ -0,0 +1,85 @@
+import { basename, date, immediateEntries, isHidden, log, readJson, readText, sanitize, titleize, truncate, write } from "./shared.js";
+function describe(item) {
+    const name = basename(item);
+    // `find -L` follows a symlink only for its direct target. fs.statSync mirrors that.
+    try {
+        if ((awaitStat(item)).isDirectory()) {
+            const fs = requireFs();
+            return `${fs.readdirSync(item).filter((entry) => !entry.startsWith(".")).length} item(s)`;
+        }
+    }
+    catch {
+        return name;
+    }
+    if (name.endsWith(".md"))
+        return readText(item)?.match(/^# +(.+)$/m)?.[1] || name;
+    if (name.endsWith(".yaml") || name.endsWith(".yml")) {
+        const found = readText(item)?.match(/^description:\s*(.*)$/m)?.[1]?.replace(/^["']|["']$/g, "");
+        return found || name;
+    }
+    if (name.endsWith(".json")) {
+        const parsed = readJson(item);
+        return typeof parsed?.description === "string" ? parsed.description : typeof parsed?.name === "string" ? parsed.name : name;
+    }
+    return name;
+}
+// Avoid a heavier tree abstraction here: the source script's `find -L` is
+// specifically about knowledge gitlinks, so stat is intentionally local.
+function requireFs() { return fsModule; }
+import * as fsModule from "fs";
+function awaitStat(file) { return fsModule.statSync(file); }
+export function renderCompanyKnowledge(context) {
+    const written = [];
+    for (const companyDir of immediateEntries(context.root, "companies", "dir")) {
+        const company = basename(companyDir);
+        if (company.startsWith("_") || isHidden(company))
+            continue;
+        const relative = `companies/${company}/knowledge`;
+        const knowledge = `${companyDir}/knowledge`;
+        try {
+            if (!fsModule.statSync(knowledge).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const entries = fsModule.readdirSync(knowledge).flatMap((name) => {
+            const item = `${knowledge}/${name}`;
+            try {
+                return fsModule.statSync(item).isDirectory() ? [item] : [];
+            }
+            catch {
+                return [];
+            }
+        }).sort().concat(fsModule.readdirSync(knowledge).flatMap((name) => {
+            const item = `${knowledge}/${name}`;
+            try {
+                return fsModule.statSync(item).isFile() ? [item] : [];
+            }
+            catch {
+                return [];
+            }
+        }).sort());
+        const lines = [`# ${titleize(company)} Knowledge`, "", `> Auto-generated. Updated: ${date(context.now)}`, "", "| Name | Description |", "|------|-------------|"];
+        for (const item of entries) {
+            const name = basename(item);
+            if (isHidden(name) || name === "INDEX.md")
+                continue;
+            const value = truncate(sanitize(describe(item)), 100) || "—";
+            let directory = false;
+            try {
+                directory = fsModule.statSync(item).isDirectory();
+            }
+            catch { /* omitted */ }
+            lines.push(`| \`${name}${directory ? "/" : ""}\` | ${value} |`);
+        }
+        lines.push("");
+        const output = `${relative}/INDEX.md`;
+        write(context, output, lines.join("\n"));
+        written.push(output);
+        log(context, `rebuild-company-knowledge-index: wrote ${output}`);
+    }
+    log(context, `rebuild-company-knowledge-index: regenerated ${written.length} knowledge INDEX.md file(s)`);
+    return { written };
+}
+//# sourceMappingURL=company-knowledge.js.map

package/dist/lib/index-render/index.d.ts

@@ -0,0 +1,5 @@
+import { RenderContext, RenderResult } from "./shared.js";
+export type IndexTarget = "all" | "companies" | "company-knowledge" | "orchestrator" | "projects" | "public-knowledge" | "reports" | "social-drafts" | "threads" | "workers";
+export declare function renderIndexTarget(target: IndexTarget, context: RenderContext, args?: string[]): RenderResult;
+export { atomicWrite, comparePath, immediateEntries, type RenderContext, type RenderResult } from "./shared.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/index-render/index.js

@@ -0,0 +1,43 @@
+import { renderCompanies } from "./companies.js";
+import { renderCompanyKnowledge } from "./company-knowledge.js";
+import { renderOrchestrator } from "./orchestrator.js";
+import { renderProjects } from "./projects.js";
+import { renderPublicKnowledge } from "./public-knowledge.js";
+import { renderReports } from "./reports.js";
+import { renderSocialDrafts } from "./social-drafts.js";
+import { renderThreads } from "./threads.js";
+import { renderWorkers } from "./workers.js";
+const allOrder = ["threads", "orchestrator", "companies", "projects", "company-knowledge", "public-knowledge", "workers", "reports", "social-drafts"];
+export function renderIndexTarget(target, context, args = []) {
+    switch (target) {
+        case "companies": return renderCompanies(context);
+        case "company-knowledge": return renderCompanyKnowledge(context);
+        case "orchestrator": return renderOrchestrator(context);
+        case "projects": return renderProjects(context);
+        case "public-knowledge": return renderPublicKnowledge(context);
+        case "reports": return renderReports(context);
+        case "social-drafts": return renderSocialDrafts(context);
+        case "threads": return renderThreads(context, args);
+        case "workers": return renderWorkers(context);
+        case "all": {
+            const written = [];
+            let errors = 0;
+            for (const child of allOrder) {
+                try {
+                    written.push(...renderIndexTarget(child, context).written);
+                }
+                catch (_error) {
+                    errors += 1;
+                    context.log?.(`rebuild-all-indexes: ERROR in rebuild-${child}-index.sh`);
+                }
+            }
+            // The shell sorts and deduplicates the `wrote` paths before JSON output.
+            const stdoutPaths = written.filter((file) => /^(workspace|companies|knowledge|workers|projects)/.test(file));
+            (context.output ?? ((message) => process.stdout.write(message)))(`${JSON.stringify([...new Set(stdoutPaths)].sort(), null, 2)}\n`);
+            context.log?.(errors ? `all-indexes: errors (${errors})` : "all-indexes: ok");
+            return { written };
+        }
+    }
+}
+export { atomicWrite, comparePath, immediateEntries } from "./shared.js";
+//# sourceMappingURL=index.js.map

package/dist/lib/index-render/orchestrator.d.ts

@@ -0,0 +1,3 @@
+import { RenderContext, RenderResult } from "./shared.js";
+export declare function renderOrchestrator(context: RenderContext): RenderResult;
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/lib/index-render/orchestrator.js

@@ -0,0 +1,52 @@
+import * as fs from "fs";
+import { at, log, readJson, timestamp, write } from "./shared.js";
+function stateFiles(root) {
+    const base = at(root, "workspace/orchestrator");
+    try {
+        // The source intentionally does not sort this `find`; opendir's iterator
+        // preserves the directory stream order rather than readdirSync's sorting.
+        const stream = fs.opendirSync(base);
+        const entries = [];
+        try {
+            for (let entry = stream.readSync(); entry; entry = stream.readSync()) {
+                if (entry.name === "_archive" || entry.name === "_pipeline")
+                    continue;
+                const state = `${base}/${entry.name}/state.json`;
+                if (fs.existsSync(state))
+                    entries.push(state);
+            }
+        }
+        finally {
+            stream.closeSync();
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+function scalar(value, fallback) { return typeof value === "string" ? value : fallback; }
+export function renderOrchestrator(context) {
+    fs.mkdirSync(at(context.root, "workspace/orchestrator"), { recursive: true });
+    const rows = [];
+    for (const file of stateFiles(context.root)) {
+        const state = readJson(file);
+        if (!state) {
+            log(context, `rebuild-orchestrator-index: WARNING: skipped unparseable ${file}: invalid JSON`);
+            continue;
+        }
+        if (["completed", "complete"].includes(scalar(state.status, "")) || scalar(state.phase, "") === "complete")
+            continue;
+        const source = scalar(state.prd_path, scalar(state.scope, ""));
+        const company = source.match(/companies\/([^/]+)\//)?.[1] ?? "-";
+        const progress = state.progress && typeof state.progress === "object" && !Array.isArray(state.progress)
+            ? `${typeof state.progress.completed === "number" ? state.progress.completed : 0}/${typeof state.progress.total === "number" ? state.progress.total : 0}` : "-";
+        rows.push(`| ${scalar(state.project, scalar(state.run_id, "-"))} | ${company} | ${scalar(state.status, "-")} | ${progress} | ${scalar(state.updated_at, "-")} |`);
+    }
+    const output = "workspace/orchestrator/INDEX.md";
+    const text = ["# Orchestrator Projects", "", `Generated: ${timestamp(context.now)}`, "", "Active runs only. Archived runs in `workspace/orchestrator/_archive/`.", "", "| Project | Company | Status | Progress | Last Updated |", "|---------|---------|--------|----------|--------------|", ...rows, ""].join("\n");
+    write(context, output, text);
+    log(context, `rebuild-orchestrator-index: wrote ${output} (${rows.length} active)`);
+    return { written: [output] };
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/lib/index-render/projects.d.ts

@@ -0,0 +1,3 @@
+import { RenderContext, RenderResult } from "./shared.js";
+export declare function renderProjects(context: RenderContext): RenderResult;
+//# sourceMappingURL=projects.d.ts.map

package/dist/lib/index-render/projects.js

@@ -0,0 +1,33 @@
+import * as path from "path";
+import { basename, date, exists, immediateEntries, isHidden, log, projectStatus, readJson, sanitize, truncate, write } from "./shared.js";
+export function renderProjects(context) {
+    const base = "personal/projects";
+    if (!exists(context.root, base)) {
+        log(context, "rebuild-projects-index: personal/projects/ missing, skipping");
+        return { written: [] };
+    }
+    const lines = ["# Projects", "", `> Auto-generated. Updated: ${date(context.now)}`, "", "Personal/HQ projects only. Company-scoped projects live in `companies/{co}/projects/`.", "", "## Company Project Directories", "", "| Company | Path |", "|---------|------|"];
+    for (const companyDirectory of immediateEntries(context.root, "companies", "dir")) {
+        const company = basename(companyDirectory);
+        if (!company.startsWith("_") && !isHidden(company) && exists(context.root, `companies/${company}/projects`))
+            lines.push(`| ${company} | \`companies/${company}/projects/\` |`);
+    }
+    lines.push("", "## Personal/HQ Projects", "", "Projects here are HQ infrastructure or cross-company tools.", "", "| Project | Stories | Status | Description |", "|---------|---------|--------|-------------|");
+    const projects = immediateEntries(context.root, base, "dir");
+    for (const directory of projects) {
+        const name = basename(directory);
+        if (name.startsWith("_") || isHidden(name))
+            continue;
+        const prd = path.join(directory, "prd.json");
+        const parsed = readJson(prd);
+        const stories = Array.isArray(parsed?.userStories) && parsed.userStories.length > 0 ? String(parsed.userStories.length) : "—";
+        const description = truncate(sanitize(typeof parsed?.description === "string" ? parsed.description : ""), 110) || "—";
+        lines.push(`| \`${name}/\` | ${stories} | ${projectStatus(context.root, name, prd, "—")} | ${description} |`);
+    }
+    lines.push("");
+    const output = `${base}/INDEX.md`;
+    write(context, output, lines.join("\n"));
+    log(context, `rebuild-projects-index: wrote ${output} (${projects.length} HQ project(s))`);
+    return { written: [output] };
+}
+//# sourceMappingURL=projects.js.map

package/dist/lib/index-render/public-knowledge.d.ts

@@ -0,0 +1,3 @@
+import { RenderContext, RenderResult } from "./shared.js";
+export declare function renderPublicKnowledge(context: RenderContext): RenderResult;
+//# sourceMappingURL=public-knowledge.d.ts.map

package/dist/lib/index-render/public-knowledge.js

@@ -0,0 +1,37 @@
+import { basename, countImmediate, date, exists, heading, immediateEntries, isHidden, log, sanitize, truncate, write } from "./shared.js";
+export function renderPublicKnowledge(context) {
+    const base = "core/knowledge/public";
+    if (!exists(context.root, base)) {
+        log(context, "rebuild-public-knowledge-index: core/knowledge/public/ missing, skipping");
+        return { written: [] };
+    }
+    const directories = immediateEntries(context.root, base, "dir");
+    const lines = ["# Public Knowledge", "", `> Auto-generated. Updated: ${date(context.now)}`, "", "| Name | Description |", "|------|-------------|"];
+    for (const directory of directories) {
+        const name = basename(directory);
+        if (isHidden(name))
+            continue;
+        const relative = `${base}/${name}`;
+        const count = countImmediate(context.root, relative, (child) => child.endsWith(".md") && child !== "INDEX.md");
+        let value = heading(`${directory}/README.md`);
+        if (!value) {
+            const first = immediateEntries(context.root, relative, "file").filter((file) => file.endsWith(".md") && !file.endsWith("/INDEX.md") && !file.endsWith("/README.md"))[0];
+            if (first)
+                value = heading(first);
+        }
+        value = value ? `${value} (${count} file(s))` : `${count} file(s)`;
+        lines.push(`| \`${name}/\` | ${truncate(sanitize(value), 100)} |`);
+    }
+    for (const file of immediateEntries(context.root, base, "file").filter((item) => item.endsWith(".md"))) {
+        const name = basename(file);
+        if (name === "INDEX.md" || isHidden(name))
+            continue;
+        lines.push(`| \`${name}\` | ${truncate(sanitize(heading(file) || name), 100)} |`);
+    }
+    lines.push("");
+    const output = `${base}/INDEX.md`;
+    write(context, output, lines.join("\n"));
+    log(context, `rebuild-public-knowledge-index: wrote ${output} (${directories.length} subdir(s))`);
+    return { written: [output] };
+}
+//# sourceMappingURL=public-knowledge.js.map

package/dist/lib/index-render/reports.d.ts

@@ -0,0 +1,3 @@
+import { RenderContext, RenderResult } from "./shared.js";
+export declare function renderReports(context: RenderContext): RenderResult;
+//# sourceMappingURL=reports.d.ts.map

package/dist/lib/index-render/reports.js

@@ -0,0 +1,37 @@
+import { basename, countImmediate, date, exists, heading, immediateEntries, isHidden, log, readText, sanitize, truncate, write } from "./shared.js";
+function reportDescription(file) {
+    const name = basename(file);
+    if (name.endsWith(".md"))
+        return heading(file) || name.slice(0, -3);
+    if (/\.html?$/.test(name))
+        return readText(file)?.match(/<title>(.*?)<\/title>/i)?.[1] || name.replace(/\.[^.]+$/, "");
+    return name;
+}
+function reportDate(name) { return name.match(/^(\d{4}-(?:\d{2}-\d{2}|W\d{2}))/)?.[1] ?? "—"; }
+export function renderReports(context) {
+    const base = "workspace/reports";
+    if (!exists(context.root, base)) {
+        log(context, "rebuild-reports-index: workspace/reports/ missing, skipping");
+        return { written: [] };
+    }
+    const lines = ["# Reports", "", `> Auto-generated. Updated: ${date(context.now)}`, "", "Personal/HQ reports only. Company reports moved to `companies/{co}/data/reports/`.", "", "## Directories", "", "| Name | Description |", "|------|-------------|"];
+    for (const directory of immediateEntries(context.root, base, "dir")) {
+        const name = basename(directory);
+        if (!isHidden(name))
+            lines.push(`| \`${name}/\` | ${countImmediate(context.root, `${base}/${name}`, (child) => !isHidden(child))} item(s) |`);
+    }
+    lines.push("", "## Individual Reports", "", "| Name | Date | Description |", "|------|------|-------------|");
+    const files = immediateEntries(context.root, base, "file");
+    for (const file of files) {
+        const name = basename(file);
+        if (name === "INDEX.md" || isHidden(name))
+            continue;
+        lines.push(`| \`${name}\` | ${reportDate(name)} | ${truncate(sanitize(reportDescription(file)), 100) || "—"} |`);
+    }
+    lines.push("");
+    const output = `${base}/INDEX.md`;
+    write(context, output, lines.join("\n"));
+    log(context, `rebuild-reports-index: wrote ${output} (${files.filter((file) => basename(file) !== "INDEX.md").length} individual report(s))`);
+    return { written: [output] };
+}
+//# sourceMappingURL=reports.js.map

package/dist/lib/index-render/shared.d.ts

@@ -0,0 +1,35 @@
+export type RenderContext = {
+    root: string;
+    now?: Date;
+    log?: (message: string) => void;
+    output?: (message: string) => void;
+};
+export type RenderResult = {
+    written: string[];
+};
+export declare function rel(root: string, file: string): string;
+export declare function at(root: string, relative: string): string;
+export declare function exists(root: string, relative: string): boolean;
+/** Bytewise, locale-independent ordering matching `find … | sort`. */
+export declare function comparePath(a: string, b: string): number;
+export declare function immediateEntries(root: string, relative: string, kind: "dir" | "file", followSymlinks?: boolean): string[];
+export declare function countImmediate(root: string, relative: string, predicate: (name: string, file: string) => boolean): number;
+export declare function readText(file: string): string | undefined;
+export declare function readJson(file: string): Record<string, unknown> | undefined;
+export declare function heading(file: string): string;
+export declare function sanitize(value: unknown): string;
+/** Bash's character-count truncation; filenames and fixture text are UTF-8. */
+export declare function truncate(value: string, length: number): string;
+export declare function titleize(slug: string): string;
+export declare function date(now?: Date): string;
+export declare function timestamp(now?: Date): string;
+/** Write via a same-directory temporary file, then atomically replace the destination. */
+export declare function atomicWrite(file: string, content: string): void;
+export declare function write(context: RenderContext, relative: string, content: string): string;
+export declare function log(context: RenderContext, message: string): void;
+export declare function projectStatus(root: string, project: string, prdPath: string, fallback: string): string;
+export declare function basename(file: string): string;
+export declare function isHidden(name: string): boolean;
+export declare function mtime(file: string): number;
+export declare function tempDirectory(prefix: string): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/lib/index-render/shared.js

@@ -0,0 +1,126 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+export function rel(root, file) {
+    return path.relative(root, file).split(path.sep).join("/");
+}
+export function at(root, relative) {
+    return path.join(root, ...relative.split("/"));
+}
+export function exists(root, relative) {
+    return fs.existsSync(at(root, relative));
+}
+/** Bytewise, locale-independent ordering matching `find … | sort`. */
+export function comparePath(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+export function immediateEntries(root, relative, kind, followSymlinks = false) {
+    const base = at(root, relative);
+    try {
+        return fs.readdirSync(base).flatMap((name) => {
+            const candidate = path.join(base, name);
+            try {
+                const stat = followSymlinks ? fs.statSync(candidate) : fs.lstatSync(candidate);
+                return (kind === "dir" ? stat.isDirectory() : stat.isFile()) ? [candidate] : [];
+            }
+            catch {
+                return [];
+            }
+        }).sort(comparePath);
+    }
+    catch {
+        return [];
+    }
+}
+export function countImmediate(root, relative, predicate) {
+    try {
+        return fs.readdirSync(at(root, relative)).filter((name) => predicate(name, at(root, `${relative}/${name}`))).length;
+    }
+    catch {
+        return 0;
+    }
+}
+export function readText(file) {
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readJson(file) {
+    const text = readText(file);
+    if (text === undefined)
+        return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function heading(file) {
+    return readText(file)?.match(/^# +(.+)$/m)?.[1] ?? "";
+}
+export function sanitize(value) {
+    return String(value ?? "").replace(/\n/g, " ").replace(/\|/g, "\\|").replace(/  */g, " ").trim();
+}
+/** Bash's character-count truncation; filenames and fixture text are UTF-8. */
+export function truncate(value, length) {
+    return value.length <= length ? value : `${value.slice(0, length - 1)}…`;
+}
+export function titleize(slug) {
+    return slug.split("-").map((part) => part ? `${part[0].toUpperCase()}${part.slice(1)}` : "").join(" ");
+}
+export function date(now = new Date()) { return now.toISOString().slice(0, 10); }
+export function timestamp(now = new Date()) { return now.toISOString().replace(/\.\d{3}Z$/, "Z"); }
+/** Write via a same-directory temporary file, then atomically replace the destination. */
+export function atomicWrite(file, content) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`);
+    try {
+        fs.writeFileSync(temporary, content, "utf8");
+        fs.renameSync(temporary, file);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch { /* best-effort cleanup */ }
+        throw error;
+    }
+}
+export function write(context, relative, content) {
+    atomicWrite(at(context.root, relative), content);
+    return relative;
+}
+export function log(context, message) { context.log?.(message); }
+export function projectStatus(root, project, prdPath, fallback) {
+    const state = readJson(at(root, `workspace/orchestrator/${project}/state.json`));
+    if (state) {
+        const raw = typeof state.status === "string" ? state.status : "active";
+        if (["completed", "complete"].includes(raw))
+            return "complete";
+        if (["in_progress", "active", "started"].includes(raw))
+            return "active";
+        return raw;
+    }
+    const prd = readJson(prdPath);
+    if (prd && Array.isArray(prd.userStories) && prd.userStories.length > 0 && prd.userStories.every((story) => Boolean(story.passes)))
+        return "complete";
+    return fallback;
+}
+export function basename(file) { return path.basename(file); }
+export function isHidden(name) { return name.startsWith("."); }
+export function mtime(file) { try {
+    return fs.statSync(file).mtimeMs / 1000;
+}
+catch {
+    return 0;
+} }
+// Kept exported for primitive tests and consumers that need a temp base without
+// relying on an application-specific fixture location.
+export function tempDirectory(prefix) { return fs.mkdtempSync(path.join(os.tmpdir(), prefix)); }
+//# sourceMappingURL=shared.js.map

package/dist/lib/index-render/social-drafts.d.ts

@@ -0,0 +1,3 @@
+import { RenderContext, RenderResult } from "./shared.js";
+export declare function renderSocialDrafts(context: RenderContext): RenderResult;
+//# sourceMappingURL=social-drafts.d.ts.map

package/dist/lib/index-render/social-drafts.js

@@ -0,0 +1,53 @@
+import * as fs from "fs";
+import { basename, countImmediate, date, exists, heading, immediateEntries, isHidden, log, mtime, sanitize, truncate, write } from "./shared.js";
+function directoryDescription(context, name) {
+    const base = `workspace/social-drafts/${name}`;
+    const files = countImmediate(context.root, base, (child, file) => !isHidden(child) && fs.statSync(file).isFile());
+    const dirs = countImmediate(context.root, base, (child, file) => !isHidden(child) && fs.statSync(file).isDirectory());
+    if (name === "x")
+        return `X/Twitter post drafts (${files} files)`;
+    if (name === "linkedin")
+        return `LinkedIn post drafts (${files} files)`;
+    if (name === "blog")
+        return `Blog post drafts (${files} files)`;
+    if (name === "tiktok")
+        return `TikTok scripts/drafts (${files} files)`;
+    if (name === "images")
+        return `Infographics and post images (${dirs} dirs)`;
+    return dirs > 0 ? `${dirs} subdir(s), ${files} file(s)` : `${files} file(s)`;
+}
+function fileDescription(file) { const name = basename(file); if (name.endsWith(".md"))
+    return heading(file) || name.slice(0, -3); if (name.endsWith(".json"))
+    return `${name.slice(0, -5)} data`; if (/\.(py|sh)$/.test(name))
+    return `Script: ${name}`; return name; }
+export function renderSocialDrafts(context) {
+    const base = "workspace/social-drafts";
+    if (!exists(context.root, base)) {
+        log(context, "rebuild-social-drafts-index: workspace/social-drafts/ missing, skipping");
+        return { written: [] };
+    }
+    const recent = ["x", "linkedin", "blog", "tiktok"].flatMap((channel) => immediateEntries(context.root, `${base}/${channel}`, "file").filter((file) => file.endsWith(".md"))).sort((a, b) => mtime(b) - mtime(a)).slice(0, 20);
+    const lines = ["# Social Drafts", "", `> Auto-generated. Updated: ${date(context.now)}`, "", "## Recent Drafts", ""];
+    for (const file of recent) {
+        const relative = file.slice(`${context.root}/workspace/social-drafts/`.length);
+        lines.push(`- \`${relative}\` - ${truncate(sanitize(heading(file) || basename(file).slice(0, -3)), 100)}`);
+    }
+    lines.push("", "## Directories", "", "| Name | Description |", "|------|-------------|");
+    for (const directory of immediateEntries(context.root, base, "dir")) {
+        const name = basename(directory);
+        if (!isHidden(name))
+            lines.push(`| \`${name}/\` | ${truncate(sanitize(directoryDescription(context, name)), 100)} |`);
+    }
+    for (const file of immediateEntries(context.root, base, "file")) {
+        const name = basename(file);
+        if (name !== "INDEX.md" && !isHidden(name))
+            lines.push(`| \`${name}\` | ${truncate(sanitize(fileDescription(file)), 100)} |`);
+    }
+    lines.push("");
+    const output = `${base}/INDEX.md`;
+    write(context, output, lines.join("\n"));
+    const draftCount = ["x", "linkedin", "blog", "tiktok"].reduce((sum, channel) => sum + immediateEntries(context.root, `${base}/${channel}`, "file").filter((file) => file.endsWith(".md")).length, 0);
+    log(context, `rebuild-social-drafts-index: wrote ${output} (${draftCount} draft file(s))`);
+    return { written: [output] };
+}
+//# sourceMappingURL=social-drafts.js.map

package/dist/lib/index-render/threads.d.ts

@@ -0,0 +1,3 @@
+import { RenderContext, RenderResult } from "./shared.js";
+export declare function renderThreads(context: RenderContext, args?: string[]): RenderResult;
+//# sourceMappingURL=threads.d.ts.map

package/dist/lib/index-render/threads.js

@@ -0,0 +1,42 @@
+import * as fs from "fs";
+import { at, log, readJson, sanitize, timestamp, write } from "./shared.js";
+export function renderThreads(context, args = []) {
+    const mode = args[0] ?? "--index";
+    const directory = at(context.root, "workspace/threads");
+    fs.mkdirSync(directory, { recursive: true });
+    // Match `ls -t`: newest filesystem modification time first. `updated_at` is
+    // rendered metadata only, and must not influence the order.
+    const files = fs.readdirSync(directory)
+        .filter((name) => /^T-.*\.json$/.test(name) && !name.endsWith(".changeset.json"))
+        .map((name) => `${directory}/${name}`)
+        .sort((a, b) => {
+        const aTime = fs.statSync(a, { bigint: true }).mtimeNs;
+        const bTime = fs.statSync(b, { bigint: true }).mtimeNs;
+        return bTime > aTime ? 1 : bTime < aTime ? -1 : 0;
+    });
+    const rows = files.flatMap((file) => {
+        const data = readJson(file);
+        if (!data)
+            return [];
+        const metadata = data.metadata && typeof data.metadata === "object" ? data.metadata : {};
+        return [`| ${typeof data.thread_id === "string" ? data.thread_id : "-"} | ${typeof data.type === "string" ? data.type : "-"} | ${typeof data.updated_at === "string" ? data.updated_at : "-"} | ${sanitize(typeof metadata.title === "string" ? metadata.title.replace(/\|/g, "/") : "-")} |`];
+    });
+    const written = [];
+    const table = (title, limited) => [
+        `# ${title}`, "", `Generated: ${timestamp(context.now)}`, `Active threads: ${files.length} (archive/ excluded)`, "", "| Thread | Type | Updated | Title |", "|--------|------|---------|-------|", ...(limited ? rows.slice(0, limited) : rows), "",
+    ].join("\n");
+    if (mode === "--index" || mode === "--both") {
+        const output = "workspace/threads/INDEX.md";
+        write(context, output, table("Threads INDEX", 0));
+        written.push(output);
+        log(context, `rebuild-threads-index: wrote ${output} (${files.length} threads)`);
+    }
+    if (mode === "--recent" || mode === "--both") {
+        const output = "workspace/threads/recent.md";
+        write(context, output, table("Recent Threads", 15));
+        written.push(output);
+        log(context, `rebuild-threads-index: wrote ${output} (last 15)`);
+    }
+    return { written };
+}
+//# sourceMappingURL=threads.js.map

package/dist/lib/index-render/workers.d.ts

@@ -0,0 +1,3 @@
+import { RenderContext, RenderResult } from "./shared.js";
+export declare function renderWorkers(context: RenderContext): RenderResult;
+//# sourceMappingURL=workers.d.ts.map

package/dist/lib/index-render/workers.js

@@ -0,0 +1,49 @@
+import * as yaml from "js-yaml";
+import { basename, date, exists, immediateEntries, isHidden, log, readText, sanitize, truncate, write } from "./shared.js";
+function workerDescription(file) {
+    const text = readText(file);
+    if (!text)
+        return "";
+    try {
+        const parsed = yaml.load(text);
+        const value = parsed?.worker?.description ?? parsed?.worker?.bio?.role;
+        return typeof value === "string" ? value : "";
+    }
+    catch {
+        return text.match(/^\s+description:\s*(.*)$/m)?.[1]?.replace(/^["']|["']$/g, "") ?? "";
+    }
+}
+function subindex(context, directory, label) {
+    if (!exists(context.root, directory))
+        return undefined;
+    const lines = [`# ${label}`, "", `> Auto-generated. Updated: ${date(context.now)}`, "", "| Name | Description |", "|------|-------------|"];
+    for (const entry of immediateEntries(context.root, directory, "dir")) {
+        const name = basename(entry);
+        if (!isHidden(name))
+            lines.push(`| \`${name}/\` | ${truncate(sanitize(workerDescription(`${entry}/worker.yaml`)), 100) || "—"} |`);
+    }
+    lines.push("");
+    const output = `${directory}/INDEX.md`;
+    write(context, output, lines.join("\n"));
+    log(context, `rebuild-workers-index: wrote ${output}`);
+    return output;
+}
+function rootIndex(context) {
+    const directory = "core/workers";
+    if (!exists(context.root, directory))
+        return undefined;
+    const lines = ["# Workers", "", `> Auto-generated. Updated: ${date(context.now)}`, "", "Shared workers live under `public/`. Private/local workers live under `personal/workers/`. `registry.yaml` is the auto-generated index (regenerated by core/scripts/generate-workers-registry.sh).", "", "| Name | Description |", "|------|-------------|"];
+    for (const entry of immediateEntries(context.root, directory, "dir")) {
+        const name = basename(entry);
+        if (isHidden(name))
+            continue;
+        lines.push(name === "public" ? "| `public/` | Shared public workers (see public/INDEX.md) |" : `| \`${name}/\` | ${truncate(sanitize(workerDescription(`${entry}/worker.yaml`)), 100) || "—"} |`);
+    }
+    lines.push("");
+    const output = `${directory}/INDEX.md`;
+    write(context, output, lines.join("\n"));
+    log(context, `rebuild-workers-index: wrote ${output}`);
+    return output;
+}
+export function renderWorkers(context) { const written = [subindex(context, "core/workers/public", "Public Workers"), subindex(context, "personal/workers", "Personal Workers"), rootIndex(context)].filter((value) => Boolean(value)); log(context, "rebuild-workers-index: done"); return { written }; }
+//# sourceMappingURL=workers.js.map

package/package.json

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