@indigoai-us/hq-cli 5.86.0 → 5.88.0

package/dist/commands/index-cmd.js

@@ -1,4 +1,6 @@
+import { Option } from 'commander';
 import { deriveCollections, listRegisteredCollections, reconcileCollections, resolveQmdBin, resolveQmdVersion, runQmd, } from '../lib/search-index/index.js';
+import { backgroundStatus, defaultBackgroundDependencies, runBackgroundLauncher, runBackgroundWorker, } from '../lib/search-index/background.js';
 import { findHqRoot } from '../utils/manifest.js';
 const defaults = {
     reconcileCollections,
@@ -7,6 +9,9 @@ const defaults = {
     resolveQmdBin,
     resolveQmdVersion,
     runQmd,
+    runBackgroundLauncher,
+    runBackgroundWorker,
+    backgroundStatus,
 };
 /** Incrementally update qmd, embedding only when an operator explicitly asks. */
 export function syncSearchIndex(hqRoot, embed, dependencies = defaults) {
@@ -18,6 +23,14 @@ export function syncSearchIndex(hqRoot, embed, dependencies = defaults) {
 function resolveRoot(hqRoot) {
     return hqRoot ?? findHqRoot();
 }
+function makeBackgroundDependencies(hqRoot, dependencies) {
+    return {
+        ...defaultBackgroundDependencies(hqRoot),
+        resolveQmdBin: dependencies.resolveQmdBin,
+        reconcileCollections: dependencies.reconcileCollections,
+        runQmd: dependencies.runQmd,
+    };
+}
 export function collectionStatusLines(expected, registered) {
     const expectedNames = new Set(expected.map((collection) => collection.name));
     const managed = expected.map((collection) => `${registered.has(collection.name) ? 'registered' : 'missing'}  ${collection.name}  ${collection.path}`);
@@ -54,6 +67,25 @@ export function registerIndexCommand(program, dependencies = defaults) {
         for (const line of collectionStatusLines(dependencies.deriveCollections(hqRoot), registered))
             console.log(line);
     });
+    index
+        .command('background')
+        .description('Run a detached, single-flight qmd cleanup and reindex')
+        .option('--log <path>', 'Write worker output to this log file')
+        .addOption(new Option('--worker').hideHelp())
+        .option('--hq-root <path>', 'HQ root to index (defaults to auto-detected root)')
+        .action((options) => {
+        const hqRoot = resolveRoot(options.hqRoot);
+        const background = makeBackgroundDependencies(hqRoot, dependencies);
+        if (options.log)
+            background.env = { ...background.env, QMD_REINDEX_LOG: options.log };
+        const result = options.worker
+            ? (dependencies.runBackgroundWorker ?? runBackgroundWorker)(background)
+            : (dependencies.runBackgroundLauncher ?? runBackgroundLauncher)(background);
+        if (!options.worker && result.state === 'launched')
+            console.log(result.pid);
+        else if (!options.worker && (result.state === 'skipped-agent' || result.state === 'skipped'))
+            console.log(result.state);
+    });
     index
         .command('status')
         .description('Show qmd binary, collection, and index status')
@@ -65,8 +97,10 @@ export function registerIndexCommand(program, dependencies = defaults) {
         const expected = dependencies.deriveCollections(hqRoot);
         const qmdStatus = dependencies.runQmd(['status'], { bin, cwd: hqRoot });
         const qmdVersion = dependencies.resolveQmdVersion();
+        const background = (dependencies.backgroundStatus ?? backgroundStatus)(makeBackgroundDependencies(hqRoot, dependencies));
         console.log(`qmd: ${bin}${qmdVersion ? ` (version ${qmdVersion})` : ''}`);
         console.log(collectionSummary(expected, registered));
+        console.log(`background: lock ${background.lock}; last completed ${background.completedAt ?? 'never'}`);
         if (qmdStatus.stdout)
             process.stdout.write(qmdStatus.stdout);
         if (qmdStatus.stderr)

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