@deftai/directive-core 0.77.0 → 0.79.0

package/dist/init-deposit/scaffold.js

@@ -9,12 +9,12 @@ import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, statSync,
 import { mkdir, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { platform } from "node:os";
 import { dirname, join, relative } from "node:path";
-import { copyTree } from "../deposit/copy-tree.js";
 import { assertProjectionContained, ProjectionContainmentError, } from "../fs/projection-containment.js";
 import { agentsRefreshPlan } from "../platform/agents-md.js";
 import { MIGRATED_ARTIFACT_DIR } from "../xbrief-migrate/constants.js";
 import { CANONICAL_INSTALL_ROOT } from "./constants.js";
 import { installerManagedGuardEre } from "./hygiene.js";
+import { syncConsumerXbriefSchemas } from "./xbrief-projections.js";
 export { CANONICAL_INSTALL_ROOT };
 export const CORE_GLOB = ".deft/core/**";
 /** Refuse init/update projection writes that escape via repo-controlled symlinks (#2446). */
@@ -336,20 +336,14 @@ export async function writeConsumerVbrief(projectDir, deftDir, io) {
     const schemasPresent = existsSync(schemasDst) && statSync(schemasDst).isDirectory();
     const vbriefMdPresent = existsSync(vbriefMdDst) && statSync(vbriefMdDst).isFile();
     const lifecyclePresent = vbriefLifecycleDirsPresent(consumerVbrief);
+    const schemasChanged = syncConsumerXbriefSchemas(projectDir, deftDir);
     if (schemasPresent && vbriefMdPresent && lifecyclePresent) {
-        io.printf("vbrief/ already present at project root — skipping.\n");
-        return false;
+        io.printf(schemasChanged
+            ? "vbrief/ schemas refreshed at project root.\n"
+            : "vbrief/ already present at project root — skipping.\n");
+        return schemasChanged;
     }
     mkdirSync(consumerVbrief, { recursive: true });
-    if (!schemasPresent) {
-        const fwSchemas = join(deftDir, "vbrief", "schemas");
-        if (existsSync(fwSchemas) && statSync(fwSchemas).isDirectory()) {
-            await copyTree(fwSchemas, schemasDst);
-        }
-        else {
-            mkdirSync(schemasDst, { recursive: true });
-        }
-    }
     if (!vbriefMdPresent) {
         const fwVbriefMd = join(deftDir, "vbrief", "vbrief.md");
         if (existsSync(fwVbriefMd)) {

package/dist/init-deposit/xbrief-projections.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Idempotent consumer xBRIEF derivatives maintained by init/update (#2595).
+ *
+ * The framework payload manifest and consumer projections have independent
+ * freshness. A current `.deft/core/VERSION` therefore cannot short-circuit
+ * these repairs.
+ */
+/**
+ * Synchronize framework-owned xBRIEF schemas while preserving unknown consumer
+ * files. The obsolete v0.6 root schema is the only destination-only file this
+ * repair removes.
+ */
+export declare function syncConsumerXbriefSchemas(projectDir: string, deftDir: string): boolean;
+/** Regenerate the bare consumer version derivative, retaining the historical root fallback. */
+export declare function syncBareVersionMarker(projectDir: string, version: string): boolean;
+/** Repair an existing marker without creating root state when no lifecycle artifact exists. */
+export declare function syncExistingBareVersionMarker(projectDir: string, version: string): boolean;
+//# sourceMappingURL=xbrief-projections.d.ts.map

package/dist/init-deposit/xbrief-projections.js

@@ -0,0 +1,117 @@
+/**
+ * Idempotent consumer xBRIEF derivatives maintained by init/update (#2595).
+ *
+ * The framework payload manifest and consumer projections have independent
+ * freshness. A current `.deft/core/VERSION` therefore cannot short-circuit
+ * these repairs.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { join, relative } from "node:path";
+import { assertProjectionContained } from "../fs/projection-containment.js";
+import { resolveLifecycleRoot } from "../layout/resolve.js";
+import { DEV_FALLBACK } from "../platform/constants.js";
+import { MIGRATED_ARTIFACT_DIR } from "../xbrief-migrate/constants.js";
+const OBSOLETE_CORE_SCHEMA = "vbrief-core.schema.json";
+const CURRENT_CORE_SCHEMA = "xbrief-core-0.8.schema.json";
+function normalizeVersion(version) {
+    return version.trim().replace(/^v/, "");
+}
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function collectSchemaFiles(root, dir = root, files = []) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isSymbolicLink()) {
+            throw new Error(`refusing xbrief schema projection from symlink: ${full}`);
+        }
+        if (entry.isDirectory()) {
+            collectSchemaFiles(root, full, files);
+        }
+        else if (entry.isFile()) {
+            files.push(relative(root, full));
+        }
+    }
+    return files;
+}
+function writeFileIfChanged(projectDir, target, content) {
+    assertProjectionContained(projectDir, target);
+    const desired = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");
+    try {
+        if (readFileSync(target).equals(desired))
+            return false;
+    }
+    catch {
+        // Missing or unreadable target is replaced below.
+    }
+    mkdirSync(join(target, ".."), { recursive: true });
+    writeFileSync(target, desired);
+    return true;
+}
+/**
+ * Synchronize framework-owned xBRIEF schemas while preserving unknown consumer
+ * files. The obsolete v0.6 root schema is the only destination-only file this
+ * repair removes.
+ */
+export function syncConsumerXbriefSchemas(projectDir, deftDir) {
+    const sourceDir = join(deftDir, "vbrief", "schemas");
+    const currentSource = join(sourceDir, CURRENT_CORE_SCHEMA);
+    if (!isDirectory(sourceDir) || !existsSync(currentSource) || !statSync(currentSource).isFile()) {
+        throw new Error(`cannot project xbrief schemas: framework payload is missing ${CURRENT_CORE_SCHEMA}`);
+    }
+    const destinationDir = join(projectDir, MIGRATED_ARTIFACT_DIR, "schemas");
+    assertProjectionContained(projectDir, destinationDir);
+    mkdirSync(destinationDir, { recursive: true });
+    let changed = false;
+    for (const rel of collectSchemaFiles(sourceDir)) {
+        if (rel === OBSOLETE_CORE_SCHEMA)
+            continue;
+        const source = join(sourceDir, rel);
+        const destination = join(destinationDir, rel);
+        changed = writeFileIfChanged(projectDir, destination, readFileSync(source)) || changed;
+    }
+    const obsoleteDestination = join(destinationDir, OBSOLETE_CORE_SCHEMA);
+    assertProjectionContained(projectDir, obsoleteDestination);
+    if (existsSync(obsoleteDestination)) {
+        rmSync(obsoleteDestination, { force: true });
+        changed = true;
+    }
+    return changed;
+}
+function syncBareVersionMarkerWithPolicy(projectDir, version, allowRootFallback) {
+    const normalized = normalizeVersion(version);
+    if (!normalized || normalized === DEV_FALLBACK)
+        return false;
+    const canonicalRoot = join(projectDir, MIGRATED_ARTIFACT_DIR);
+    if (existsSync(canonicalRoot)) {
+        assertProjectionContained(projectDir, join(canonicalRoot, ".deft-version"));
+    }
+    let targetDir = projectDir;
+    try {
+        targetDir = resolveLifecycleRoot(projectDir);
+    }
+    catch {
+        // Preserve the historical root fallback for payload-changing refreshes,
+        // and repair an existing fallback on no-op refreshes without creating new
+        // untracked state (#2118 / #2595).
+        const rootMarker = join(projectDir, ".deft-version");
+        if (!allowRootFallback && !existsSync(rootMarker))
+            return false;
+    }
+    const target = join(targetDir, ".deft-version");
+    return writeFileIfChanged(projectDir, target, `${normalized}\n`);
+}
+/** Regenerate the bare consumer version derivative, retaining the historical root fallback. */
+export function syncBareVersionMarker(projectDir, version) {
+    return syncBareVersionMarkerWithPolicy(projectDir, version, true);
+}
+/** Repair an existing marker without creating root state when no lifecycle artifact exists. */
+export function syncExistingBareVersionMarker(projectDir, version) {
+    return syncBareVersionMarkerWithPolicy(projectDir, version, false);
+}
+//# sourceMappingURL=xbrief-projections.js.map

package/dist/intake/reconcile-issues.d.ts

@@ -26,13 +26,19 @@ export interface FetchIssuesOptions {
 export declare function fetchOpenIssues(repo: string, options?: FetchIssuesOptions): Record<string, unknown>[] | null;
 export declare function fetchAllOpenIssues(repo: string, options?: FetchIssuesOptions): Record<string, unknown>[] | null;
 export interface FetchIssueStatesOptions extends FetchIssuesOptions {
+    /** @deprecated REST fetch is per-issue; batch size is ignored (#2557 / #954). */
     readonly batchSize?: number;
 }
 export declare function fetchIssueStates(repo: string, issueNumbers: ReadonlySet<number>, options?: FetchIssueStatesOptions): Map<number, IssueState> | null;
+export interface CompletedStatusDriftEntry {
+    readonly rel_path: string;
+    readonly status: string;
+}
 export interface ReconcileReport {
     linked: Record<string, unknown>[];
     no_open_issue: Record<string, unknown>[];
     unlinked?: Record<string, unknown>[];
+    completed_status_drift?: CompletedStatusDriftEntry[];
     summary: Record<string, number>;
 }
 export declare function reconcile(issueToVbriefs: Map<number, string[]>, issueStateMap: Map<number, IssueState | string>): ReconcileReport;
@@ -42,10 +48,15 @@ export declare function parseParentIssue(data: Record<string, unknown>): number
 export declare function parseDecompositionOrigin(data: Record<string, unknown>): number | null;
 export declare function resolveLifecycleAnchor(data: Record<string, unknown>): [number | null, string];
 export declare function scanLifecycleAnchors(vbriefDir: string): Record<string, unknown>[];
+/** Scan completed/ for xBRIEFs whose plan.status is not terminal (D2 drift, #2578). */
+export declare function scanCompletedStatusDrift(vbriefDir: string): CompletedStatusDriftEntry[];
+export declare function attachCompletedStatusDrift(report: ReconcileReport, drift: CompletedStatusDriftEntry[]): ReconcileReport;
 export declare function buildLifecycleReport(anchors: Record<string, unknown>[], issueStateMap: Map<number, IssueState | string>, log?: boolean): ReconcileReport;
 export declare function formatJson(report: ReconcileReport): string;
 export declare function formatMarkdown(report: ReconcileReport): string;
 export declare function applyLifecycleFixes(vbriefDir: string, report: ReconcileReport, projectRoot?: string | null): [number, number, string[]];
+/** Repair completed/ files whose plan.status is not terminal (#2578). */
+export declare function repairCompletedStatusDrift(vbriefDir: string, drift: readonly CompletedStatusDriftEntry[]): [number, number, string[]];
 export declare function detectRepo(): string | null;
 export interface ReconcileCliArgs {
     vbriefDir?: string;

package/dist/intake/reconcile-issues.js

@@ -6,6 +6,7 @@ import { call } from "../scm/call.js";
 import { updateDecomposedChildBackReferences } from "../scope/decomposed-refs.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveProjectRepo } from "../slice/project-context.js";
+import { FOLDER_ALLOWED_STATUSES } from "../vbrief-validate/constants.js";
 import { LEGACY_INFO_ROOT_KEY, MIGRATED_INFO_ROOT_KEY } from "../xbrief-migrate/constants.js";
 export const LIFECYCLE_FOLDERS = [
     "proposed",
@@ -188,6 +189,52 @@ function splitRepoSlug(repo) {
     }
     return [parts[0], parts[1]];
 }
+function normalizeRestIssueState(raw) {
+    if (typeof raw !== "string" || raw.length === 0) {
+        return "NOT_FOUND";
+    }
+    return raw.toUpperCase();
+}
+function normalizeRestStateReason(raw) {
+    if (typeof raw !== "string" || raw.length === 0) {
+        return null;
+    }
+    return raw.toUpperCase();
+}
+function isRestNotFoundResult(result) {
+    const stderr = result.stderr.trim();
+    return (stderr.includes("404") ||
+        stderr.includes("Not Found") ||
+        stderr.includes("Could not resolve to an Issue"));
+}
+function issueStateFromRestPayload(payload) {
+    return new IssueState(normalizeRestIssueState(payload.state), normalizeRestStateReason(payload.state_reason));
+}
+function fetchOneIssueStateRest(owner, name, issueNumber, scmCall, cwd) {
+    let result;
+    try {
+        result = scmCall("github-issue", "api", [`repos/${owner}/${name}/issues/${issueNumber}`], {
+            timeout: 30,
+            cwd,
+        });
+    }
+    catch {
+        return "CLI_MISSING";
+    }
+    if (result.returncode !== 0) {
+        if (isRestNotFoundResult(result)) {
+            return new IssueState("NOT_FOUND", null);
+        }
+        process.stderr.write(`Error: gh REST failed fetching issue #${issueNumber}: ${result.stderr.trim()}\n`);
+        return null;
+    }
+    try {
+        return issueStateFromRestPayload(JSON.parse(result.stdout));
+    }
+    catch {
+        return null;
+    }
+}
 export function fetchIssueStates(repo, issueNumbers, options = {}) {
     if (issueNumbers.size === 0) {
         return new Map();
@@ -198,63 +245,19 @@ export function fetchIssueStates(repo, issueNumbers, options = {}) {
         return null;
     }
     const [owner, name] = parsed;
-    const batchSize = options.batchSize ?? GRAPHQL_BATCH_SIZE;
     const sortedNumbers = [...issueNumbers].sort((a, b) => a - b);
     const states = new Map();
     const scmCall = options.scmCall ?? call;
-    for (let start = 0; start < sortedNumbers.length; start += batchSize) {
-        const batch = sortedNumbers.slice(start, start + batchSize);
-        const aliases = batch
-            .map((n) => `i${n}: issue(number: ${n}) { state stateReason }`)
-            .join("\n    ");
-        const query = `query {\n  repository(owner: "${owner}", name: "${name}") {\n    ${aliases}\n  }\n}\n`;
-        let result;
-        try {
-            result = scmCall("github-issue", "api", ["graphql", "-f", `query=${query}`], {
-                timeout: 60,
-                cwd: options.cwd ?? undefined,
-            });
-        }
-        catch {
+    for (const n of sortedNumbers) {
+        const fetched = fetchOneIssueStateRest(owner, name, n, scmCall, options.cwd ?? undefined);
+        if (fetched === "CLI_MISSING") {
             process.stderr.write("Error: gh CLI not found. Install GitHub CLI.\n");
             return null;
         }
-        let payload = null;
-        try {
-            payload = result.stdout ? JSON.parse(result.stdout) : null;
-        }
-        catch {
-            payload = null;
-        }
-        if (result.returncode !== 0) {
-            if (payload === null || typeof payload.data !== "object" || payload.data === null) {
-                process.stderr.write(`Error: gh CLI failed: ${result.stderr.trim()}\n`);
-                return null;
-            }
-            const firstLine = result.stderr.trim().split("\n")[0] ?? "";
-            process.stderr.write(`Warning: gh GraphQL returned partial errors (likely PR numbers referenced as issues): ${firstLine}\n`);
-        }
-        if (payload === null) {
-            process.stderr.write("Error: failed to parse gh CLI graphql output.\n");
-            return null;
-        }
-        const repoData = payload.data?.repository;
-        if (repoData === null || typeof repoData !== "object" || Array.isArray(repoData)) {
-            process.stderr.write("Error: gh CLI graphql response missing repository payload.\n");
+        if (fetched === null) {
             return null;
         }
-        for (const n of batch) {
-            const node = repoData[`i${n}`];
-            if (node !== null && typeof node === "object" && !Array.isArray(node)) {
-                const nodeObj = node;
-                if (typeof nodeObj.state === "string") {
-                    const reason = typeof nodeObj.stateReason === "string" ? nodeObj.stateReason : null;
-                    states.set(n, new IssueState(nodeObj.state, reason));
-                    continue;
-                }
-            }
-            states.set(n, new IssueState("NOT_FOUND", null));
-        }
+        states.set(n, fetched);
     }
     return states;
 }
@@ -433,6 +436,52 @@ export function scanLifecycleAnchors(vbriefDir) {
     }
     return anchors;
 }
+const COMPLETED_TERMINAL_STATUSES = FOLDER_ALLOWED_STATUSES.completed ?? new Set(["completed", "failed"]);
+/** Scan completed/ for xBRIEFs whose plan.status is not terminal (D2 drift, #2578). */
+export function scanCompletedStatusDrift(vbriefDir) {
+    const completedDir = join(vbriefDir, "completed");
+    const drift = [];
+    try {
+        if (!statSync(completedDir).isDirectory()) {
+            return drift;
+        }
+    }
+    catch {
+        return drift;
+    }
+    for (const filename of readdirSync(completedDir)
+        .filter((f) => hasArtifactSuffix(f))
+        .sort()) {
+        const relPath = `completed/${filename}`;
+        let data;
+        try {
+            data = JSON.parse(readFileSync(join(completedDir, filename), "utf8"));
+        }
+        catch {
+            continue;
+        }
+        const plan = data.plan;
+        if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+            continue;
+        }
+        const status = String(plan.status ?? "");
+        if (status.length === 0 || COMPLETED_TERMINAL_STATUSES.has(status)) {
+            continue;
+        }
+        drift.push({ rel_path: relPath, status });
+    }
+    return drift;
+}
+export function attachCompletedStatusDrift(report, drift) {
+    return {
+        ...report,
+        completed_status_drift: drift,
+        summary: {
+            ...report.summary,
+            completed_status_drift_count: drift.length,
+        },
+    };
+}
 export function buildLifecycleReport(anchors, issueStateMap, log = true) {
     const linked = [];
     const noOpenIssue = [];
@@ -525,6 +574,18 @@ export function formatMarkdown(report) {
         lines.push("None.");
     }
     lines.push("");
+    lines.push("## (d) completed/ xBRIEFs with non-terminal plan.status (D2 drift)", "");
+    const drift = report.completed_status_drift ?? [];
+    if (drift.length > 0) {
+        for (const entry of drift) {
+            const safeStatus = entry.status.replace(/\r?\n/g, " ");
+            lines.push(`- \`${entry.rel_path}\` -- plan.status='${safeStatus}'`);
+        }
+    }
+    else {
+        lines.push("None.");
+    }
+    lines.push("");
     return lines.join("\n");
 }
 function utcNowIso() {
@@ -661,6 +722,54 @@ export function applyLifecycleFixes(vbriefDir, report, projectRoot = null) {
     }
     return [moved, skipped, failures];
 }
+/** Repair completed/ files whose plan.status is not terminal (#2578). */
+export function repairCompletedStatusDrift(vbriefDir, drift) {
+    let repaired = 0;
+    let skipped = 0;
+    const failures = [];
+    const completedDir = join(vbriefDir, "completed");
+    for (const entry of drift) {
+        const slash = entry.rel_path.indexOf("/");
+        if (slash < 0) {
+            failures.push(`unexpected vBRIEF path shape (no folder): ${JSON.stringify(entry.rel_path)}`);
+            continue;
+        }
+        const filename = entry.rel_path.slice(slash + 1);
+        const src = join(completedDir, filename);
+        let data;
+        try {
+            data = JSON.parse(readFileSync(src, "utf8"));
+        }
+        catch (exc) {
+            failures.push(`failed to parse ${entry.rel_path}: ${String(exc)}`);
+            continue;
+        }
+        const plan = (data.plan ?? {});
+        data.plan = plan;
+        const currentStatus = String(plan.status ?? "");
+        if (COMPLETED_TERMINAL_STATUSES.has(currentStatus)) {
+            skipped += 1;
+            continue;
+        }
+        const stamp = utcNowIso();
+        plan.status = "completed";
+        plan.updated = stamp;
+        const infoKey = MIGRATED_INFO_ROOT_KEY in data ? MIGRATED_INFO_ROOT_KEY : LEGACY_INFO_ROOT_KEY;
+        const info = (data[infoKey] ?? {});
+        data[infoKey] = info;
+        info.updated = stamp;
+        propagateItemStatus(plan.items, "completed", stamp);
+        try {
+            writeFileSync(src, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+        }
+        catch (exc) {
+            failures.push(`failed to write ${entry.rel_path}: ${String(exc)}`);
+            continue;
+        }
+        repaired += 1;
+    }
+    return [repaired, skipped, failures];
+}
 export function detectRepo() {
     try {
         const stdout = execFileSync("git", ["remote", "get-url", "origin"], {
@@ -742,6 +851,8 @@ export function reconcileMain(args) {
         report = reconcile(issueToVbriefsObj, issueStateMap);
     }
     const fmt = args.format ?? "markdown";
+    const completedDrift = scanCompletedStatusDrift(vbriefDir);
+    report = attachCompletedStatusDrift(report, completedDrift);
     if (fmt === "json") {
         process.stdout.write(formatJson(report));
     }
@@ -759,11 +870,15 @@ export function reconcileMain(args) {
             return acc;
         }, 0);
         const [moved, skipped, failures] = applyLifecycleFixes(vbriefDir, applyReport, projectRoot);
+        const driftAfterMove = scanCompletedStatusDrift(vbriefDir);
+        const [driftRepaired, driftSkipped, driftFailures] = repairCompletedStatusDrift(vbriefDir, driftAfterMove);
+        const allFailures = [...failures, ...driftFailures];
         process.stderr.write(`[${moved}/${candidates}] vBRIEFs reconciled (moved=${moved}, already-terminal=${skipped}, failures=${failures.length})\n`);
-        for (const f of failures) {
+        process.stderr.write(`[${driftRepaired}/${completedDrift.length}] completed/ status drift repaired (repaired=${driftRepaired}, already-terminal=${driftSkipped}, failures=${driftFailures.length})\n`);
+        for (const f of allFailures) {
             process.stderr.write(`  -- FAIL: ${f}\n`);
         }
-        if (failures.length > 0) {
+        if (allFailures.length > 0) {
             return 1;
         }
     }

package/dist/issue-sync/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./sync-from-xbrief.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/issue-sync/index.js

@@ -0,0 +1,2 @@
+export * from "./sync-from-xbrief.js";
+//# sourceMappingURL=index.js.map

package/dist/issue-sync/sync-from-xbrief-cli.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+export interface ParsedSyncFromXbriefCliArgs {
+    path?: string;
+    dryRun?: boolean;
+    projectRoot?: string;
+    repo?: string;
+    error?: string;
+}
+export declare function parseArgs(argv: readonly string[]): ParsedSyncFromXbriefCliArgs;
+export declare function mainEntry(argv?: string[]): number;
+//# sourceMappingURL=sync-from-xbrief-cli.d.ts.map

package/dist/issue-sync/sync-from-xbrief-cli.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { syncFromXbriefMain } from "./sync-from-xbrief.js";
+export function parseArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--dry-run") {
+            out.dryRun = true;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...out, error: "argument --project-root: expected one argument" };
+            }
+            out.projectRoot = value;
+            i += 1;
+        }
+        else if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...out, error: "argument --repo: expected one argument" };
+            }
+            out.repo = value;
+            i += 1;
+        }
+        else if (!arg.startsWith("-")) {
+            out.path = arg;
+        }
+    }
+    return out;
+}
+export function mainEntry(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`issue:sync-from-xbrief: ${args.error}\n`);
+        return 2;
+    }
+    return syncFromXbriefMain(args);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(mainEntry());
+}
+//# sourceMappingURL=sync-from-xbrief-cli.js.map

package/dist/issue-sync/sync-from-xbrief.d.ts

@@ -0,0 +1,46 @@
+import { type RunGhApiFn } from "../intake/github-body.js";
+export declare const SYNC_COMMENT_HEADER = "## xBRIEF sync (deft issue:sync-from-xbrief)";
+export interface OriginIssueTarget {
+    readonly repo: string;
+    readonly number: number;
+    readonly uri: string;
+}
+export interface SyncSnapshot {
+    readonly status: string;
+    readonly title: string;
+    readonly acceptance: string;
+    readonly items: readonly {
+        title: string;
+        status: string;
+    }[];
+}
+export interface ResolveOriginOptions {
+    readonly fallbackRepo?: string | null;
+}
+export declare function resolveOriginIssue(data: Record<string, unknown>, options?: ResolveOriginOptions): OriginIssueTarget | null;
+export declare function extractSyncSnapshot(data: Record<string, unknown>): SyncSnapshot;
+export declare function fingerprintSyncSnapshot(snapshot: SyncSnapshot): string;
+export declare function readStoredFingerprint(data: Record<string, unknown>): string | null;
+export declare function hasMaterialChanges(data: Record<string, unknown>): boolean;
+export declare function sanitizeMarkdownInline(text: string): string;
+export declare function buildSyncComment(data: Record<string, unknown>, xbriefPath: string): string;
+export interface SyncFromXbriefOptions {
+    readonly xbriefPath: string;
+    readonly dryRun?: boolean;
+    readonly projectRoot?: string;
+    readonly repo?: string;
+    readonly runFn?: RunGhApiFn;
+    readonly writeErr?: (message: string) => void;
+    readonly writeOut?: (message: string) => void;
+    readonly writeFingerprint?: (absPath: string, data: Record<string, unknown>) => void;
+}
+export declare function stampIssueSyncFingerprint(data: Record<string, unknown>, origin: OriginIssueTarget): Record<string, unknown>;
+export declare function syncFromXbrief(options: SyncFromXbriefOptions): number;
+export interface SyncFromXbriefCliArgs {
+    readonly path?: string;
+    readonly dryRun?: boolean;
+    readonly projectRoot?: string;
+    readonly repo?: string;
+}
+export declare function syncFromXbriefMain(args: SyncFromXbriefCliArgs): number;
+//# sourceMappingURL=sync-from-xbrief.d.ts.map