@indigoai-us/hq-cli 5.314.0 → 5.315.0

package/dist/lib/work-context/outbox-quarantine-status-flag.js

@@ -0,0 +1,7 @@
+import { resolveProcessFlagGate } from "../flag-registry.js";
+export const OUTBOX_QUARANTINE_STATUS_FLAG = "agents.work-context-outbox-quarantine-status";
+export const OUTBOX_QUARANTINE_STATUS_FALLBACK = false;
+export function outboxQuarantineStatusEnabled() {
+    return resolveProcessFlagGate(OUTBOX_QUARANTINE_STATUS_FLAG, { fallback: OUTBOX_QUARANTINE_STATUS_FALLBACK }, () => OUTBOX_QUARANTINE_STATUS_FALLBACK);
+}
+//# sourceMappingURL=outbox-quarantine-status-flag.js.map

package/dist/lib/work-context/outbox.d.ts

@@ -5,7 +5,7 @@
 import type { DeliveryState } from "./contract.js";
 import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
 /** Fields allowed on a durable outbox operation (privacy allowlist). */
-export declare const OUTBOX_ALLOWLIST: readonly ["contractVersion", "operationId", "clientOperationId", "sessionId", "harness", "companyUid", "companySlug", "projectId", "taskId", "kind", "digest", "delivery", "createdAt", "updatedAt", "attemptCount", "lastErrorCode", "receiptId", "destinationCompanyUid", "destinationCompanySlug", "nextAttemptAt"];
+export declare const OUTBOX_ALLOWLIST: readonly ["contractVersion", "operationId", "clientOperationId", "sessionId", "harness", "companyUid", "companySlug", "projectId", "taskId", "companyConfidence", "kind", "digest", "delivery", "createdAt", "updatedAt", "attemptCount", "lastErrorCode", "lastErrorHttpStatus", "lastServerErrorCode", "receiptId", "destinationCompanyUid", "destinationCompanySlug", "nextAttemptAt"];
 /** Base delay for outbox retry backoff (attempt 1 → 30s). */
 export declare const OUTBOX_RETRY_BASE_MS = 30000;
 /** Cap for outbox retry backoff (6 hours). */
@@ -25,6 +25,8 @@ export interface OutboxOperation {
     companySlug?: string;
     projectId?: string;
     taskId?: string;
+    /** Durable provenance for weak device-default bindings. */
+    companyConfidence?: "device_default";
     kind: OutboxKind;
     digest: string;
     delivery: DeliveryState;
@@ -32,6 +34,8 @@ export interface OutboxOperation {
     updatedAt: string;
     attemptCount: number;
     lastErrorCode?: string;
+    lastErrorHttpStatus?: number;
+    lastServerErrorCode?: string;
     receiptId?: string;
     /** Destination company for kind=migrate (source is companyUid). */
     destinationCompanyUid?: string;
@@ -47,6 +51,7 @@ export interface OutboxEnqueueInput {
     companySlug?: string;
     projectId?: string;
     taskId?: string;
+    companyConfidence?: "device_default";
     kind?: OutboxKind;
     destinationCompanyUid?: string;
     destinationCompanySlug?: string;
@@ -62,6 +67,7 @@ export declare function digestOperation(parts: {
     companySlug?: string;
     projectId?: string;
     taskId?: string;
+    companyConfidence?: "device_default";
     kind: OutboxKind;
     destinationCompanyUid?: string;
     destinationCompanySlug?: string;
@@ -76,8 +82,21 @@ export declare function enqueueOutbox(input: OutboxEnqueueInput, root: string):
 export declare function readOutboxOperation(operationId: string, root: string): OutboxOperation | null;
 export declare function updateOutboxOperation(op: OutboxOperation, root: string): void;
 export declare function markOutboxAcked(operationId: string, root: string, receiptId: string, now?: () => Date): OutboxOperation | null;
-export declare function markOutboxQueued(operationId: string, root: string, errorCode: string, now?: () => Date, random?: () => number): OutboxOperation | null;
-export declare function markOutboxQuarantined(operationId: string, root: string, errorCode: string, now?: () => Date): OutboxOperation | null;
+/**
+ * Write server-acknowledged register scope into the session projection.
+ * This closes the outbox → emitter handoff for both direct reconciliation and
+ * daemon replay. Non-register or incomplete legacy operations are ignored.
+ */
+export declare function writeAckedRegisterState(op: OutboxOperation, root: string, receiptId: string, now?: () => Date): void;
+/** Repair older unresolved session projections from acknowledged registrations. */
+export declare function repairAckedRegisterStates(root: string, sessionIds?: ReadonlySet<string>, now?: () => Date): number;
+export declare function markOutboxQueued(operationId: string, root: string, errorCode: string, now?: () => Date, random?: () => number, details?: OutboxErrorDetails): OutboxOperation | null;
+export declare function markOutboxQuarantined(operationId: string, root: string, errorCode: string, now?: () => Date, details?: OutboxErrorDetails): OutboxOperation | null;
+export interface OutboxErrorDetails {
+    httpStatus?: number;
+    serverCode?: string;
+}
+export declare function sanitizeOutboxErrorDetails(details?: OutboxErrorDetails): OutboxErrorDetails;
 /**
  * Requeue quarantined outbox operations so the daemon's replay picks them up
  * again. Quarantine is otherwise terminal: after the work-mesh-live gap 10 fix
@@ -106,16 +125,19 @@ export interface OutboxStats {
     quarantined: number;
     queued: number;
     acked: number;
+    lastQuarantineReason: string | null;
+    lastQuarantineHttpStatus: number | null;
+    lastQuarantineServerCode: string | null;
 }
 export declare function outboxStats(root: string): OutboxStats;
 export type DeliverFn = (op: OutboxOperation) => Promise<{
     ok: true;
     receiptId: string;
-} | {
+} | ({
     ok: false;
     retryable: boolean;
     code: string;
-}>;
+} & OutboxErrorDetails)>;
 /**
  * Replay queued (and recover lost-receipt) operations.
  * FIFO per sessionId; bounded parallelism across sessions.

package/dist/lib/work-context/outbox.js

@@ -8,6 +8,8 @@ import * as path from "node:path";
 import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
 import { atomicWriteJson, ensureOwnerDir } from "./atomic.js";
 import { NotTrackingError } from "./errors.js";
+import { isWorkSessionDenialCode } from "../mesh/denial-codes.js";
+import { readSessionState, stripRegisterReceiptEpisodes, updateSessionState, writeAcknowledgedRegisterBinding, } from "./state.js";
 import { isSafeWorkContextSegment, workContextOutboxDir, workContextOutboxPath, } from "./paths.js";
 /** Fields allowed on a durable outbox operation (privacy allowlist). */
 export const OUTBOX_ALLOWLIST = [
@@ -20,6 +22,7 @@ export const OUTBOX_ALLOWLIST = [
     "companySlug",
     "projectId",
     "taskId",
+    "companyConfidence",
     "kind",
     "digest",
     "delivery",
@@ -27,6 +30,8 @@ export const OUTBOX_ALLOWLIST = [
     "updatedAt",
     "attemptCount",
     "lastErrorCode",
+    "lastErrorHttpStatus",
+    "lastServerErrorCode",
     "receiptId",
     "destinationCompanyUid",
     "destinationCompanySlug",
@@ -95,8 +100,15 @@ function projectOutbox(op) {
         out.projectId = op.projectId;
     if (op.taskId)
         out.taskId = op.taskId;
+    if (op.companyConfidence)
+        out.companyConfidence = op.companyConfidence;
     if (op.lastErrorCode)
         out.lastErrorCode = op.lastErrorCode;
+    if (op.lastErrorHttpStatus !== undefined) {
+        out.lastErrorHttpStatus = op.lastErrorHttpStatus;
+    }
+    if (op.lastServerErrorCode)
+        out.lastServerErrorCode = op.lastServerErrorCode;
     if (op.receiptId)
         out.receiptId = op.receiptId;
     if (op.destinationCompanyUid) {
@@ -142,6 +154,7 @@ export function enqueueOutbox(input, root) {
         companySlug: input.companySlug,
         projectId: input.projectId,
         taskId: input.taskId,
+        companyConfidence: input.companyConfidence,
         kind,
         destinationCompanyUid: input.destinationCompanyUid,
         destinationCompanySlug: input.destinationCompanySlug,
@@ -171,6 +184,7 @@ export function enqueueOutbox(input, root) {
         companySlug: input.companySlug,
         projectId: input.projectId,
         taskId: input.taskId,
+        companyConfidence: input.companyConfidence,
         kind,
         digest,
         delivery: "queued",
@@ -258,12 +272,86 @@ export function markOutboxAcked(operationId, root, receiptId, now = () => new Da
     updateOutboxOperation(op, root);
     return op;
 }
-export function markOutboxQueued(operationId, root, errorCode, now = () => new Date(), random = Math.random) {
+/**
+ * Write server-acknowledged register scope into the session projection.
+ * This closes the outbox → emitter handoff for both direct reconciliation and
+ * daemon replay. Non-register or incomplete legacy operations are ignored.
+ */
+export function writeAckedRegisterState(op, root, receiptId, now = () => new Date()) {
+    if (op.kind !== "register" || !op.companyUid)
+        return;
+    writeAcknowledgedRegisterBinding({
+        kind: "register",
+        sessionId: op.sessionId,
+        companyUid: op.companyUid,
+        companySlug: op.companySlug,
+        projectId: op.projectId,
+        taskId: op.taskId,
+        receiptId,
+    }, root, now);
+}
+/** Repair older unresolved session projections from acknowledged registrations. */
+export function repairAckedRegisterStates(root, sessionIds, now = () => new Date()) {
+    let repaired = 0;
+    const operations = listOutboxOperations(root);
+    // A stored bindingEpisodeId that is a register receipt makes the server drop
+    // every batch. Clear it even when the register operation that produced it is
+    // no longer in the outbox: the id shape identifies it. This runs for every
+    // requested session, whatever its company or tracking status.
+    const receiptsBySession = new Map();
+    for (const op of operations) {
+        if (op.kind !== "register" || !op.receiptId)
+            continue;
+        const receipts = receiptsBySession.get(op.sessionId) ?? [];
+        receipts.push(op.receiptId);
+        receiptsBySession.set(op.sessionId, receipts);
+    }
+    for (const sessionId of sessionIds ?? receiptsBySession.keys()) {
+        if (!isSafeWorkContextSegment(sessionId))
+            continue;
+        const known = receiptsBySession.get(sessionId) ?? [];
+        // Take the lock only for a session that needs the repair.
+        const observed = readSessionState(sessionId, root);
+        if (!observed || stripRegisterReceiptEpisodes(observed, known) === observed)
+            continue;
+        updateSessionState(sessionId, root, (current) => {
+            if (!current)
+                return null;
+            const next = stripRegisterReceiptEpisodes(current, known);
+            return next === current ? null : next;
+        });
+    }
+    for (const op of operations) {
+        if (op.delivery !== "acked" ||
+            !op.receiptId ||
+            op.kind !== "register" ||
+            !op.companyUid ||
+            (sessionIds && !sessionIds.has(op.sessionId))) {
+            continue;
+        }
+        const before = readSessionState(op.sessionId, root);
+        const after = writeAcknowledgedRegisterBinding({
+            kind: "register",
+            sessionId: op.sessionId,
+            companyUid: op.companyUid,
+            companySlug: op.companySlug,
+            projectId: op.projectId,
+            taskId: op.taskId,
+            receiptId: op.receiptId,
+        }, root, now);
+        if (after && (before?.contextStatus === "unresolved" || !before?.companyUid)) {
+            repaired += 1;
+        }
+    }
+    return repaired;
+}
+export function markOutboxQueued(operationId, root, errorCode, now = () => new Date(), random = Math.random, details) {
     const op = readOutboxOperation(operationId, root);
     if (!op)
         return null;
     op.delivery = "queued";
     op.lastErrorCode = errorCode;
+    applyOutboxErrorDetails(op, details);
     op.attemptCount += 1;
     const at = now();
     op.updatedAt = at.toISOString();
@@ -272,17 +360,40 @@ export function markOutboxQueued(operationId, root, errorCode, now = () => new D
     updateOutboxOperation(op, root);
     return op;
 }
-export function markOutboxQuarantined(operationId, root, errorCode, now = () => new Date()) {
+export function markOutboxQuarantined(operationId, root, errorCode, now = () => new Date(), details) {
     const op = readOutboxOperation(operationId, root);
     if (!op)
         return null;
     op.delivery = "quarantined";
     op.lastErrorCode = errorCode;
+    applyOutboxErrorDetails(op, details);
     op.attemptCount += 1;
     op.updatedAt = now().toISOString();
     updateOutboxOperation(op, root);
     return op;
 }
+function applyOutboxErrorDetails(op, details) {
+    delete op.lastErrorHttpStatus;
+    delete op.lastServerErrorCode;
+    const safe = sanitizeOutboxErrorDetails(details);
+    if (safe.httpStatus !== undefined)
+        op.lastErrorHttpStatus = safe.httpStatus;
+    if (safe.serverCode !== undefined)
+        op.lastServerErrorCode = safe.serverCode;
+}
+export function sanitizeOutboxErrorDetails(details) {
+    const safe = {};
+    if (details?.httpStatus !== undefined &&
+        Number.isInteger(details.httpStatus) &&
+        details.httpStatus >= 100 &&
+        details.httpStatus <= 599) {
+        safe.httpStatus = details.httpStatus;
+    }
+    if (isWorkSessionDenialCode(details?.serverCode)) {
+        safe.serverCode = details.serverCode;
+    }
+    return safe;
+}
 /**
  * Requeue quarantined outbox operations so the daemon's replay picks them up
  * again. Quarantine is otherwise terminal: after the work-mesh-live gap 10 fix
@@ -310,6 +421,8 @@ export function requeueQuarantinedOutbox(root, opts = {}) {
         op.delivery = "queued";
         op.attemptCount = 0;
         op.lastErrorCode = undefined;
+        op.lastErrorHttpStatus = undefined;
+        op.lastServerErrorCode = undefined;
         op.nextAttemptAt = undefined;
         op.updatedAt = now().toISOString();
         updateOutboxOperation(op, root);
@@ -379,11 +492,26 @@ export function listOutboxOperations(root, deps = {}) {
 }
 export function outboxStats(root) {
     const ops = listOutboxOperations(root);
+    const quarantinedOps = ops.filter((o) => o.delivery === "quarantined");
+    const latestQuarantine = quarantinedOps.reduce((latest, op) => !latest || op.updatedAt > latest.updatedAt ||
+        (op.updatedAt === latest.updatedAt && op.operationId > latest.operationId)
+        ? op
+        : latest, null);
     return {
         depth: ops.filter((o) => o.delivery === "queued").length,
-        quarantined: ops.filter((o) => o.delivery === "quarantined").length,
+        quarantined: quarantinedOps.length,
         queued: ops.filter((o) => o.delivery === "queued").length,
         acked: ops.filter((o) => o.delivery === "acked").length,
+        lastQuarantineReason: latestQuarantine?.lastErrorCode ?? null,
+        lastQuarantineHttpStatus: latestQuarantine &&
+            Number.isInteger(latestQuarantine.lastErrorHttpStatus) &&
+            latestQuarantine.lastErrorHttpStatus >= 100 &&
+            latestQuarantine.lastErrorHttpStatus <= 599
+            ? latestQuarantine.lastErrorHttpStatus
+            : null,
+        lastQuarantineServerCode: isWorkSessionDenialCode(latestQuarantine?.lastServerErrorCode)
+            ? latestQuarantine.lastServerErrorCode
+            : null,
     };
 }
 function isOutboxDue(op, nowIso) {
@@ -461,22 +589,23 @@ export async function replayOutbox(root, deliver, opts = {}) {
             const result = await deliver(op);
             if (result.ok) {
                 markOutboxAcked(op.operationId, root, result.receiptId, now);
+                writeAckedRegisterState(op, root, result.receiptId, now);
                 delivered += 1;
             }
             else if (result.retryable) {
                 if (op.attemptCount + 1 >= OUTBOX_MAX_ATTEMPTS) {
-                    markOutboxQuarantined(op.operationId, root, `${result.code}_MAX_ATTEMPTS`, now);
+                    markOutboxQuarantined(op.operationId, root, `${result.code}_MAX_ATTEMPTS`, now, result);
                     quarantined += 1;
                 }
                 else {
-                    markOutboxQueued(op.operationId, root, result.code, now, random);
+                    markOutboxQueued(op.operationId, root, result.code, now, random, result);
                     queued += 1;
                 }
                 // Stop this session's FIFO on transient failure.
                 break;
             }
             else {
-                markOutboxQuarantined(op.operationId, root, result.code, now);
+                markOutboxQuarantined(op.operationId, root, result.code, now, result);
                 quarantined += 1;
                 break;
             }

package/dist/lib/work-context/prd-sync.d.ts

@@ -0,0 +1,56 @@
+/**
+ * US-040 / F14: diff a bound project's prd.json and describe task_status events.
+ * A same-company PRD for a different project is a project switch (rebindTo).
+ * A PRD in another company is skipped. Planning never touches the network.
+ * The snapshot is written only after the caller accepts the plan (commit),
+ * so a failed emit can retry.
+ */
+import { type SessionStateFile } from "./state.js";
+export interface PrdStatusEvent {
+    taskId: string;
+    status: "done" | "in_progress" | "review";
+}
+export interface PrdSnapshot {
+    stories: Record<string, {
+        passes: boolean;
+        status?: string;
+    }>;
+    seq: number;
+    /** Project the snapshot belongs to. A switch starts a fresh story set. */
+    projectId?: string;
+}
+export declare function prdSnapshotPath(sessionId: string, root: string): string;
+export declare function readPrdSnapshot(sessionId: string, root: string): PrdSnapshot | null;
+/** `companies/<slug>/projects/<projectId>/prd.json` — nowhere else. */
+export declare function prdPathIdentity(file: string): {
+    companySlug: string;
+    projectId: string;
+} | null;
+export declare function prdBelongsToProject(file: string, projectId: string, companySlug: string | undefined): boolean;
+export declare function rebindSessionToProject(input: {
+    sessionId: string;
+    root: string;
+    projectId: string;
+    now?: () => Date;
+}): SessionStateFile | null;
+export interface PrdSyncPlan {
+    changed: boolean;
+    skip?: "no_state" | "not_bound" | "different_project" | "unreadable";
+    events: PrdStatusEvent[];
+    /** Same-company project the session should switch to before emit. */
+    rebindTo?: string;
+    /** Story most recently moved to in_progress, if any. */
+    taskId?: string;
+    seqStart: number;
+    /**
+     * Write the snapshot. With no argument, every planned story is recorded.
+     * With ids, only those stories advance; the rest stay changed for a retry.
+     */
+    commit: (acceptedTaskIds?: readonly string[]) => void;
+}
+export declare function planPrdSync(input: {
+    sessionId: string;
+    file: string;
+    root: string;
+}): PrdSyncPlan;
+//# sourceMappingURL=prd-sync.d.ts.map

package/dist/lib/work-context/prd-sync.js

@@ -0,0 +1,197 @@
+/**
+ * US-040 / F14: diff a bound project's prd.json and describe task_status events.
+ * A same-company PRD for a different project is a project switch (rebindTo).
+ * A PRD in another company is skipped. Planning never touches the network.
+ * The snapshot is written only after the caller accepts the plan (commit),
+ * so a failed emit can retry.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readSessionState, updateSessionState } from "./state.js";
+import { mapReaderStoryStatus } from "../mesh/story-status.js";
+export function prdSnapshotPath(sessionId, root) {
+    return path.join(root, "sessions", `${sessionId}.prd-snapshot.json`);
+}
+export function readPrdSnapshot(sessionId, root) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(prdSnapshotPath(sessionId, root), "utf8"));
+        if (!parsed || typeof parsed !== "object" || !parsed.stories)
+            return null;
+        return {
+            stories: parsed.stories,
+            seq: typeof parsed.seq === "number" ? parsed.seq : 0,
+            ...(typeof parsed.projectId === "string" && parsed.projectId.trim()
+                ? { projectId: parsed.projectId.trim() }
+                : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** `companies/<slug>/projects/<projectId>/prd.json` — nowhere else. */
+export function prdPathIdentity(file) {
+    const parts = path.resolve(file).split(path.sep);
+    if (parts[parts.length - 1] !== "prd.json")
+        return null;
+    const projectsAt = parts.lastIndexOf("projects");
+    if (projectsAt < 2 || parts[projectsAt - 2] !== "companies" || parts.length !== projectsAt + 3) {
+        return null;
+    }
+    const companySlug = parts[projectsAt - 1];
+    const projectId = parts[projectsAt + 1];
+    if (!companySlug || !projectId)
+        return null;
+    return { companySlug, projectId };
+}
+function writeSnapshot(sessionId, root, snapshot) {
+    const dest = prdSnapshotPath(sessionId, root);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, `${JSON.stringify(snapshot)}\n`, { mode: 0o600 });
+}
+export function prdBelongsToProject(file, projectId, companySlug) {
+    if (!companySlug)
+        return false;
+    const identity = prdPathIdentity(file);
+    return Boolean(identity &&
+        identity.companySlug.toLowerCase() === companySlug.toLowerCase() &&
+        identity.projectId === projectId);
+}
+export function rebindSessionToProject(input) {
+    const nowIso = (input.now ?? (() => new Date()))().toISOString();
+    return updateSessionState(input.sessionId, input.root, (current) => {
+        if (!current)
+            return null;
+        if (current.projectId === input.projectId)
+            return current;
+        return {
+            ...current,
+            projectId: input.projectId,
+            taskId: undefined,
+            contextStatus: current.contextStatus === "bound" || current.contextStatus === "needs_task"
+                ? "needs_task"
+                : current.contextStatus,
+            projectBindReason: `prd-sync project switch to ${input.projectId}`,
+            updatedAt: nowIso,
+        };
+    });
+}
+function storiesFromPrd(file) {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    const rows = Array.isArray(parsed.userStories) ? parsed.userStories
+        : Array.isArray(parsed.stories) ? parsed.stories
+            : [];
+    const out = [];
+    for (const row of rows) {
+        if (!row || typeof row !== "object")
+            continue;
+        const id = row.id;
+        if (typeof id !== "string" || !id.trim())
+            continue;
+        const rawStatus = mapReaderStoryStatus(row);
+        const status = rawStatus?.trim() ? rawStatus.trim() : undefined;
+        out.push({
+            id: id.trim(),
+            passes: row.passes === true,
+            ...(status ? { status } : {}),
+        });
+    }
+    return out;
+}
+export function planPrdSync(input) {
+    const empty = (skip) => ({
+        changed: false,
+        skip,
+        events: [],
+        seqStart: 0,
+        commit: () => { },
+    });
+    let state;
+    try {
+        state = readSessionState(input.sessionId, input.root);
+    }
+    catch {
+        return empty("unreadable");
+    }
+    if (!state)
+        return empty("no_state");
+    if (!state.projectId || (state.contextStatus !== "bound" && state.contextStatus !== "needs_task")) {
+        return empty("not_bound");
+    }
+    const identity = prdPathIdentity(input.file);
+    if (!identity || !state.companySlug)
+        return empty("different_project");
+    if (identity.companySlug.toLowerCase() !== state.companySlug.toLowerCase()) {
+        return empty("different_project");
+    }
+    const targetProjectId = identity.projectId;
+    const rebindTo = state.projectId !== targetProjectId ? targetProjectId : undefined;
+    let stories;
+    try {
+        stories = storiesFromPrd(input.file);
+    }
+    catch {
+        return empty("unreadable");
+    }
+    const previousRaw = readPrdSnapshot(input.sessionId, input.root);
+    const previousProject = previousRaw?.projectId ?? state.projectId;
+    const previous = previousProject === targetProjectId ? previousRaw : null;
+    const before = previous?.stories ?? {};
+    const events = [];
+    let taskId;
+    const nextStories = {};
+    for (const story of stories) {
+        nextStories[story.id] = {
+            passes: story.passes,
+            ...(story.status ? { status: story.status } : {}),
+        };
+        const prior = previous ? before[story.id] : undefined;
+        if ((story.passes || story.status === "done") && !prior?.passes && prior?.status !== "done") {
+            events.push({ taskId: story.id, status: "done" });
+            continue;
+        }
+        if (story.status === "in_progress" && prior?.status !== "in_progress") {
+            events.push({ taskId: story.id, status: "in_progress" });
+            taskId = story.id;
+        }
+        if (story.status === "review" && prior?.status !== "review") {
+            events.push({ taskId: story.id, status: "review" });
+        }
+    }
+    const snapshot = {
+        stories: nextStories,
+        seq: (previous?.seq ?? 0) + events.length,
+        projectId: targetProjectId,
+    };
+    return {
+        changed: events.length > 0,
+        events,
+        ...(rebindTo ? { rebindTo } : {}),
+        ...(taskId ? { taskId } : {}),
+        seqStart: previous?.seq ?? 0,
+        commit: (acceptedTaskIds) => {
+            if (!acceptedTaskIds) {
+                writeSnapshot(input.sessionId, input.root, snapshot);
+                return;
+            }
+            const accepted = new Set(acceptedTaskIds);
+            const stories = { ...(previous?.stories ?? {}) };
+            let advanced = 0;
+            for (const event of events) {
+                if (!accepted.has(event.taskId))
+                    continue;
+                const next = nextStories[event.taskId];
+                if (!next)
+                    continue;
+                stories[event.taskId] = next;
+                advanced += 1;
+            }
+            writeSnapshot(input.sessionId, input.root, {
+                stories,
+                seq: (previous?.seq ?? 0) + advanced,
+                projectId: targetProjectId,
+            });
+        },
+    };
+}
+//# sourceMappingURL=prd-sync.js.map

package/dist/lib/work-context/preflight-contract.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Offline preflight ContextResult shapes that `hq mesh context reconcile --offline`
+ * can emit. migration_pending is a migrate-path status, not a preflight result.
+ *
+ * contractVersion is WORK_CONTEXT_CONTRACT_VERSION. Bump it only together with
+ * contracts/preflight/v<N>/ and the vendored copy in hq-core
+ * (core/hooks/SessionStart/preflight-fixtures.json). Each side pins the version
+ * in tests; a one-sided bump fails that side until the other is updated.
+ */
+import { type ContextResult } from "./contract.js";
+export declare const PREFLIGHT_CONTRACT_VERSION: 1;
+/** Classifications reconcile actually returns on the offline preflight path. */
+export declare const OFFLINE_PREFLIGHT_CLASSIFICATIONS: readonly ["unresolved", "needs_company", "company_conflict", "needs_project", "needs_task", "bound", "untracked"];
+export type OfflinePreflightClassification = (typeof OFFLINE_PREFLIGHT_CLASSIFICATIONS)[number];
+/**
+ * One representative result per emitted classification, using the kind and
+ * delivery the offline path actually returns (company-resolved results are
+ * kind "queued" / delivery "queued"; local-only results are delivery "clean").
+ */
+export declare function preflightFixtureFor(classification: OfflinePreflightClassification): ContextResult;
+export interface PreflightFixtureFile {
+    contractVersion: typeof PREFLIGHT_CONTRACT_VERSION;
+    source: "hq-cli contracts/preflight/v1/fixtures.json";
+    classifications: readonly OfflinePreflightClassification[];
+    fixtures: ContextResult[];
+}
+export declare function buildPreflightFixtures(): PreflightFixtureFile;
+//# sourceMappingURL=preflight-contract.d.ts.map