@indigoai-us/hq-cli 5.314.0 → 5.315.0

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

@@ -5,13 +5,17 @@
 import * as fs from "node:fs";
 import { InvalidSessionIdentityError, normalizeSessionIdentity, } from "../mesh/live/session-identity.js";
 import { companyCorrectionPath, companySlugFromCwd, resolveCompany, } from "./company.js";
+import { companyBindingChanged, isNonCloudCompanySlug, presenceLeaveFromState, reboundSessionProjection, } from "./company-rebind.js";
+import { invalidateDefaultCompanyMemberships, } from "./config.js";
 import { WORK_CONTEXT_CONTRACT_VERSION, normalizeTaskId, } from "./contract.js";
 import { EXIT_INVALID_IDENTITY, EXIT_NOT_TRACKING, EXIT_OK, InvalidDecisionOriginError, NotTrackingError, } from "./errors.js";
 import { decisionFromCandidates, } from "./organize.js";
+import { refineProjectBinding } from "./bind-best.js";
+import { rebindNeedsProjectOnPrompt } from "./prompt-rebind.js";
 import { resolveProjectTask, shouldAskAfter } from "./project.js";
 import { deriveRemoteOwnerSlug, deriveRepoIdentityKey } from "./repo-remote.js";
-import { enqueueOutbox, markOutboxAcked, markOutboxQuarantined, markOutboxQueued, replayOutbox, } from "./outbox.js";
-import { mergeLocalSessionFields, readSessionState, writeSessionState, } from "./state.js";
+import { enqueueOutbox, listOutboxOperations, markOutboxAcked, markOutboxQuarantined, markOutboxQueued, replayOutbox, sanitizeOutboxErrorDetails, writeAckedRegisterState, } from "./outbox.js";
+import { mergeLocalSessionFields, isRegisterReceiptEpisodeId, readSessionState, stripRegisterReceiptEpisodes, writeSessionState, } from "./state.js";
 function resultOf(parts) {
     const out = {
         contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
@@ -24,6 +28,8 @@ function resultOf(parts) {
     };
     if (parts.companyUid)
         out.companyUid = parts.companyUid;
+    if (parts.companySlug)
+        out.companySlug = parts.companySlug;
     if (parts.projectId)
         out.projectId = parts.projectId;
     if (parts.taskId)
@@ -32,6 +38,14 @@ function resultOf(parts) {
         out.bindingEpisodeId = parts.bindingEpisodeId;
     if (parts.errorCode)
         out.errorCode = parts.errorCode;
+    if (parts.httpStatus !== undefined)
+        out.httpStatus = parts.httpStatus;
+    if (parts.serverCode)
+        out.serverCode = parts.serverCode;
+    if (parts.projectBindReason)
+        out.projectBindReason = parts.projectBindReason;
+    if (parts.projectCandidates)
+        out.projectCandidates = parts.projectCandidates;
     return out;
 }
 function parseUntrackedOrigin(obs) {
@@ -164,7 +178,22 @@ export async function reconcileObservation(obs, deps) {
         }
     }
     // Already untracked locally — stay untracked until explicit opt-in (no backfill).
-    const prior = readSessionState(sessionId, deps.root);
+    const observedPrior = readSessionState(sessionId, deps.root);
+    // Acked register operations for this session. A register response never
+    // carries a binding episode, so an already acknowledged binding is
+    // identified by its company / project / task, never by comparing the
+    // register receipt with the session's bindingEpisodeId.
+    const ackedRegisters = observedPrior
+        ? listOutboxOperations(deps.root).filter((operation) => operation.kind === "register" &&
+            operation.delivery === "acked" &&
+            operation.sessionId === sessionId &&
+            Boolean(operation.receiptId))
+        : [];
+    // Older clients stored a register receipt as the episode. Work from a
+    // projection with those cleared so no later write carries one forward.
+    const prior = observedPrior
+        ? stripRegisterReceiptEpisodes(observedPrior, ackedRegisters.map((operation) => operation.receiptId))
+        : observedPrior;
     if (prior?.contextStatus === "untracked" && prior.untrackedReceipt?.origin === "user") {
         return {
             result: resultOf({
@@ -222,6 +251,7 @@ export async function reconcileObservation(obs, deps) {
         hqRoot,
         remoteOwnerSlug,
         repoIdentityKey,
+        allowDeviceDefault: deps.allowDeviceDefault,
         existingState: prior,
     });
     const nowIso = nowFn().toISOString();
@@ -293,12 +323,10 @@ export async function reconcileObservation(obs, deps) {
             startedAt,
             ...(typeof toolWrites === "number" ? { toolWrites } : {}),
             ...(hasTurn ? { hasTurn: true } : {}),
-            // Preserve prior binding ids for visibility; do not auto-switch.
+            // Preserve prior scope for visibility; its receipt belongs to the
+            // quarantined binding and must not suppress a later retry.
             ...(prior?.projectId ? { projectId: prior.projectId } : {}),
             ...(prior?.taskId ? { taskId: prior.taskId } : {}),
-            ...(prior?.bindingEpisodeId
-                ? { bindingEpisodeId: prior.bindingEpisodeId }
-                : {}),
             ...transcriptFields,
             decision: {
                 decisionId: `conflict_${sessionId}`,
@@ -325,7 +353,7 @@ export async function reconcileObservation(obs, deps) {
                 askAfter: false,
                 ...(correctionPath ? { correctionPath } : {}),
             },
-        }, prior), deps.root);
+        }, prior, { preserveBindingEpisode: false }), deps.root);
         return {
             result: resultOf({
                 kind: "company_conflict",
@@ -343,8 +371,63 @@ export async function reconcileObservation(obs, deps) {
         };
     }
     // Membership-validated slug→uid when local resolution only yielded a slug.
+    // A device default is weak, cached evidence: validate it authoritatively on
+    // every tenant-I/O path so a membership revocation takes effect immediately.
     let resolvedCompany = company.company;
-    if (!resolvedCompany.uid && resolvedCompany.slug && deps.validateMembership) {
+    if (isNonCloudCompanySlug(resolvedCompany.slug)) {
+        const projection = prior
+            ? reboundSessionProjection({
+                prior,
+                sessionId,
+                nextSlug: resolvedCompany.slug,
+                nowIso,
+                startedAt,
+                toolWrites,
+                hasTurn,
+            })
+            : {
+                contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+                sessionId,
+                contextStatus: "needs_company",
+                companySlug: resolvedCompany.slug,
+                updatedAt: nowIso,
+                startedAt,
+                ...(typeof toolWrites === "number" ? { toolWrites } : {}),
+                ...(hasTurn ? { hasTurn: true } : {}),
+            };
+        const statePath = writeSessionState(mergeLocalSessionFields({ ...projection, ...transcriptFields }, prior, { preserveBindingEpisode: false, preserveCompanyBinding: false }), deps.root);
+        diagnostics.push(`company rebind to ${resolvedCompany.slug}; cleared project; held (non-cloud)`);
+        return {
+            result: resultOf({
+                kind: "needs_company",
+                classification: "needs_company",
+                delivery: "clean",
+                sessionId,
+                clientOperationId: obs.clientOperationId,
+                companySlug: resolvedCompany.slug,
+            }),
+            exitCode: EXIT_OK,
+            diagnostics: [...diagnostics, "needs_company: non-cloud session company; no tenant I/O"],
+            statePath,
+        };
+    }
+    const deviceDefaultRequiresValidation = resolvedCompany.source === "device_default";
+    if (deviceDefaultRequiresValidation && !deps.validateMembership) {
+        return {
+            result: resultOf({
+                kind: "needs_company",
+                classification: "needs_company",
+                delivery: "clean",
+                sessionId,
+                clientOperationId: obs.clientOperationId,
+            }),
+            exitCode: EXIT_OK,
+            diagnostics: ["needs_company: device-default membership validator unavailable"],
+        };
+    }
+    if (resolvedCompany.slug &&
+        deps.validateMembership &&
+        (!resolvedCompany.uid || deviceDefaultRequiresValidation)) {
         try {
             const membership = await deps.validateMembership(resolvedCompany.slug);
             if (membership && typeof membership === "object" && membership.uid) {
@@ -355,7 +438,11 @@ export async function reconcileObservation(obs, deps) {
                 diagnostics.push(`membership resolved companyUid for slug=${resolvedCompany.slug}`);
             }
             else if (membership === false) {
+                if (deviceDefaultRequiresValidation) {
+                    invalidateDefaultCompanyMemberships({ root: deps.root, now: nowFn });
+                }
                 diagnostics.push(`membership denied for slug=${resolvedCompany.slug}; treating as needs_company`);
+                const deniedLeave = prior ? presenceLeaveFromState(prior) : undefined;
                 const statePath = writeSessionState(mergeLocalSessionFields({
                     contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
                     sessionId,
@@ -366,7 +453,10 @@ export async function reconcileObservation(obs, deps) {
                     ...(typeof toolWrites === "number" ? { toolWrites } : {}),
                     ...(hasTurn ? { hasTurn: true } : {}),
                     ...transcriptFields,
-                }, prior), deps.root);
+                    ...(deniedLeave ? { presenceLeave: deniedLeave } : {}),
+                }, prior, companyBindingChanged(prior, resolvedCompany)
+                    ? { preserveBindingEpisode: false, preserveCompanyBinding: false }
+                    : {}), deps.root);
                 return {
                     result: resultOf({
                         kind: "needs_company",
@@ -386,16 +476,39 @@ export async function reconcileObservation(obs, deps) {
         }
         catch (err) {
             diagnostics.push(`membership lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+            if (deviceDefaultRequiresValidation) {
+                return {
+                    result: resultOf({
+                        kind: "needs_company",
+                        classification: "needs_company",
+                        delivery: "clean",
+                        sessionId,
+                        clientOperationId: obs.clientOperationId,
+                    }),
+                    exitCode: EXIT_OK,
+                    diagnostics: [...diagnostics, "needs_company: device-default membership refresh unavailable"],
+                };
+            }
         }
     }
     // Company resolved — resolve project/task (US-007B order).
+    const companyRebind = companyBindingChanged(prior, resolvedCompany);
+    const projectPrior = companyRebind && prior
+        ? {
+            ...prior,
+            projectId: undefined,
+            taskId: undefined,
+            bindingEpisodeId: undefined,
+            contextStatus: "needs_project",
+        }
+        : prior;
     let projectResolved = resolveProjectTask({
         sessionId,
         env,
         trusted,
         cwd,
         hqRoot,
-        existingState: prior,
+        existingState: projectPrior,
     });
     // Deterministic cwd projects belong to the cwd company. A higher-precedence
     // identity UID must not adopt a project from an unrelated/unverified slug.
@@ -405,8 +518,107 @@ export async function reconcileObservation(obs, deps) {
             projectResolved = null;
         }
     }
-    const projectId = projectResolved?.projectId;
-    const taskId = projectResolved?.taskId;
+    let projectId = projectResolved?.projectId;
+    let taskId = projectResolved?.taskId;
+    let projectBindReason;
+    let projectCandidates;
+    let projectGate;
+    if (projectResolved &&
+        projectId &&
+        projectResolved.source !== "existing_binding" &&
+        obs.source !== "transcript" &&
+        hqRoot &&
+        resolvedCompany.slug) {
+        const refined = refineProjectBinding({
+            hint: projectId,
+            hqRoot,
+            companySlug: resolvedCompany.slug,
+            companyUid: resolvedCompany.uid,
+            repoPath: cwd,
+            env,
+            nowMs: nowFn().getTime(),
+        });
+        if (refined.action === "bind") {
+            if (refined.projectId !== projectId)
+                taskId = undefined;
+            projectId = refined.projectId;
+            projectBindReason = refined.reason;
+            diagnostics.push(`project bind: ${refined.reason}`);
+        }
+        else if (refined.action === "create") {
+            projectBindReason = refined.reason;
+            if (!deps.offline && resolvedCompany.uid && deps.ensureProjectBoard) {
+                try {
+                    await deps.ensureProjectBoard({
+                        companyUid: resolvedCompany.uid,
+                        projectId,
+                        prdPath: refined.prdPath,
+                    });
+                    diagnostics.push(`project board created for ${projectId}`);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    diagnostics.push(`project board create failed: ${message}`);
+                    projectBindReason = `Board create failed for ${projectId}: ${message}`;
+                    projectCandidates = [{ projectId, title: projectId }];
+                    projectGate = "choose";
+                    projectId = undefined;
+                    taskId = undefined;
+                    projectResolved = null;
+                }
+            }
+            else {
+                diagnostics.push(`project bind: local PRD for ${projectId}; Board create waits for online reconcile`);
+            }
+        }
+        else if (refined.action === "ask") {
+            projectBindReason = refined.reason;
+            projectCandidates = refined.candidates;
+            projectGate = "choose";
+            projectId = undefined;
+            taskId = undefined;
+            projectResolved = null;
+            diagnostics.push(`project ask: ${refined.reason}`);
+        }
+    }
+    const promptSubmit = obs.hookEvent === "UserPromptSubmit" || obs.hookEvent === "user_prompt_submit";
+    if (promptSubmit && prior?.contextStatus === "needs_project" && !projectId && prior.companyUid) {
+        try {
+            const rebound = rebindNeedsProjectOnPrompt({
+                sessionId,
+                root: deps.root,
+                hqRoot,
+                cwd,
+                companySlug: resolvedCompany.slug ?? prior.companySlug,
+                companyUid: resolvedCompany.uid ?? prior.companyUid,
+                env,
+                nowMs: nowFn().getTime(),
+                now: nowFn,
+            });
+            if (rebound.action === "bound" && rebound.projectId) {
+                projectId = rebound.projectId;
+                projectBindReason = rebound.reason;
+                projectCandidates = undefined;
+                projectGate = undefined;
+                diagnostics.push(`prompt rebind: ${rebound.reason}`);
+            }
+        }
+        catch (err) {
+            diagnostics.push(`prompt rebind failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const projectHint = !projectId
+        ? (companyRebind ? projectResolved?.projectId : (prior?.projectHint || projectResolved?.projectId))
+        : undefined;
+    const bindResultFields = {
+        ...(projectBindReason ? { projectBindReason } : {}),
+        ...(projectCandidates ? { projectCandidates } : {}),
+    };
+    const bindStateFields = {
+        ...bindResultFields,
+        ...(projectGate ? { projectGate } : {}),
+        ...(projectHint ? { projectHint } : {}),
+    };
     // Trusted / deterministic auto-bind never asks.
     // Transcript-sourced sessions never ask (US-018).
     const fromTranscript = obs.source === "transcript";
@@ -421,7 +633,10 @@ export async function reconcileObservation(obs, deps) {
         (projectResolved.source === "deterministic_cwd" ||
             projectResolved.source === "deterministic_registry"));
     let classification;
-    if (autoBound) {
+    if (projectGate === "choose") {
+        classification = "needs_project";
+    }
+    else if (autoBound) {
         classification = "bound";
     }
     else if (projectId && taskId) {
@@ -482,7 +697,106 @@ export async function reconcileObservation(obs, deps) {
         registerClassification === "unresolved") {
         registerClassification = "needs_project";
     }
+    // Offline preflight has authoritative membership but deliberately does not
+    // invent a project. Expose that usable, validated state to hook consumers.
+    if (resolvedCompany.source === "device_default" && deps.offline && registerClassification === "unresolved") {
+        registerClassification = "needs_project";
+    }
+    // Do not let a weak later observation erase a server-acknowledged company
+    // binding. Keep the result unresolved so the normal candidate threshold can
+    // still advance the session, while preserving the durable emitter projection.
+    if (companyRebind && !projectId && resolvedCompany.uid) {
+        registerClassification = "needs_project";
+        diagnostics.push(`company rebind to ${resolvedCompany.slug ?? resolvedCompany.uid}; cleared project`);
+    }
+    const stateClassification = registerClassification === "unresolved" &&
+        prior?.contextStatus === "needs_project" &&
+        prior.companyUid === resolvedCompany.uid &&
+        (prior.bindingEpisodeId ||
+            ackedRegisters.some((operation) => operation.companyUid === resolvedCompany.uid))
+        ? "needs_project"
+        : registerClassification;
+    // Re-observing an already acknowledged binding is normal for hooks and the
+    // resident daemon. A fresh clientOperationId must not turn that observation
+    // into a second semantic register operation: the prior receipt is the stable
+    // identity for this exact company/project/task binding.
+    const priorBindingIsBound = Boolean(projectId && taskId);
+    // A state that is not an acknowledged binding (for example one quarantined
+    // as company_conflict) must register again even when its fields still match.
+    const priorIsAcknowledgedBinding = prior?.contextStatus === "bound" ||
+        prior?.contextStatus === "needs_task" ||
+        prior?.contextStatus === "needs_project" ||
+        prior?.contextStatus === "unresolved";
+    const acknowledgedReceipt = prior &&
+        priorIsAcknowledgedBinding &&
+        prior.companyUid === resolvedCompany.uid &&
+        prior.companySlug === resolvedCompany.slug &&
+        prior.projectId === projectId &&
+        prior.taskId === taskId
+        ? ackedRegisters.find((operation) => operation.companyUid === resolvedCompany.uid &&
+            operation.companySlug === resolvedCompany.slug &&
+            operation.projectId === projectId &&
+            operation.taskId === taskId)?.receiptId
+        : undefined;
+    const acknowledgedPrior = acknowledgedReceipt ? prior : null;
+    if (acknowledgedPrior) {
+        // Only a bound session holds a server episode (issued by bind / organize).
+        const retainedEpisodeId = priorBindingIsBound
+            ? acknowledgedPrior.bindingEpisodeId
+            : undefined;
+        // Activity is local progress, not binding identity. Retain the receipt
+        // without another register while carrying hook counters forward so the
+        // normal clarification threshold still advances.
+        writeSessionState(mergeLocalSessionFields({
+            contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+            sessionId,
+            companyUid: acknowledgedPrior.companyUid,
+            companySlug: acknowledgedPrior.companySlug,
+            contextStatus: stateClassification,
+            projectId,
+            taskId,
+            bindingEpisodeId: retainedEpisodeId,
+            updatedAt: nowIso,
+            startedAt,
+            ...(typeof toolWrites === "number" ? { toolWrites } : {}),
+            ...(hasTurn ? { hasTurn: true } : {}),
+            ...(decision ? { decision } : {}),
+            ...bindStateFields,
+            ...transcriptFields,
+        }, prior, { preserveBindingEpisode: priorBindingIsBound }), deps.root);
+        const kind = registerClassification === "bound"
+            ? "bound"
+            : registerClassification === "needs_task"
+                ? "needs_task"
+                : registerClassification === "needs_project"
+                    ? "needs_project"
+                    : "queued";
+        diagnostics.push(`binding unchanged; retained receipt=${acknowledgedReceipt}`);
+        return {
+            result: resultOf({
+                kind,
+                classification: registerClassification,
+                delivery: "acked",
+                sessionId,
+                clientOperationId: obs.clientOperationId,
+                companyUid: resolvedCompany.uid,
+                companySlug: resolvedCompany.slug,
+                projectId,
+                taskId,
+                ...(retainedEpisodeId ? { bindingEpisodeId: retainedEpisodeId } : {}),
+                ...bindResultFields,
+            }),
+            exitCode: EXIT_OK,
+            diagnostics,
+        };
+    }
     let outboxOp;
+    const companyConfidence = !companyRebind &&
+        company.status === "resolved" &&
+        company.company.source === "device_default"
+        ? "device_default"
+        : undefined;
+    const presenceLeave = companyRebind && prior ? presenceLeaveFromState(prior) : undefined;
     try {
         outboxOp = enqueueOutbox({
             clientOperationId: obs.clientOperationId,
@@ -492,6 +806,7 @@ export async function reconcileObservation(obs, deps) {
             companySlug: resolvedCompany.slug,
             projectId,
             taskId,
+            companyConfidence,
             kind: "register",
             now: nowFn,
         }, deps.root);
@@ -518,13 +833,14 @@ export async function reconcileObservation(obs, deps) {
         diagnostics.push(`project source=${projectResolved.source} projectId=${projectId ?? "-"} taskId=${taskId ?? "-"}`);
     }
     let statePath;
+    let stateWrite;
     try {
-        const stateWrite = mergeLocalSessionFields({
+        stateWrite = mergeLocalSessionFields({
             contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
             sessionId,
             companyUid: resolvedCompany.uid,
             companySlug: resolvedCompany.slug,
-            contextStatus: registerClassification,
+            contextStatus: stateClassification,
             projectId,
             taskId,
             updatedAt: nowIso,
@@ -532,8 +848,13 @@ export async function reconcileObservation(obs, deps) {
             ...(typeof toolWrites === "number" ? { toolWrites } : {}),
             ...(hasTurn ? { hasTurn: true } : {}),
             ...(decision ? { decision } : {}),
+            ...(companyConfidence ? { companyConfidence } : {}),
+            ...(presenceLeave ? { presenceLeave } : {}),
+            ...bindStateFields,
             ...transcriptFields,
-        }, prior);
+        }, prior, companyRebind
+            ? { preserveBindingEpisode: false, preserveCompanyBinding: false }
+            : {});
         statePath = writeSessionState(stateWrite, deps.root);
     }
     catch (err) {
@@ -546,6 +867,7 @@ export async function reconcileObservation(obs, deps) {
                     sessionId,
                     clientOperationId: obs.clientOperationId,
                     companyUid: resolvedCompany.uid,
+                    companySlug: resolvedCompany.slug,
                     projectId,
                     taskId,
                     errorCode: "NOT_TRACKING",
@@ -566,8 +888,10 @@ export async function reconcileObservation(obs, deps) {
                 sessionId,
                 clientOperationId: obs.clientOperationId,
                 companyUid: resolvedCompany.uid,
+                companySlug: resolvedCompany.slug,
                 projectId,
                 taskId,
+                ...bindResultFields,
             }),
             exitCode: EXIT_OK,
             diagnostics: [...diagnostics, "offline/local: operation remains queued"],
@@ -578,23 +902,47 @@ export async function reconcileObservation(obs, deps) {
     const delivered = await deps.deliver(outboxOp);
     if (delivered.ok) {
         markOutboxAcked(outboxOp.operationId, deps.root, delivered.receiptId, nowFn);
-        // Persist binding episode on success for bound registrations.
-        if (registerClassification === "bound") {
+        writeAckedRegisterState(outboxOp, deps.root, delivered.receiptId, nowFn);
+        // Company attribution write for EVERY acked register that resolved a
+        // company — not only bound sessions. A company-only ack (needs_project /
+        // needs_task / unresolved) must still project companyUid/companySlug and
+        // the true computed classification into durable session state; otherwise
+        // the emitter and mesh presence lose the tenant the server already
+        // acknowledged. projectId / taskId are written only when genuinely
+        // resolved. A register ack never yields a bindingEpisodeId, bound or not:
+        // the server issues episodes only on bind / organize. The default merge
+        // keeps an episode the session already holds when the binding still matches.
+        if (resolvedCompany.uid) {
+            const bound = registerClassification === "bound";
+            // A server ack of the company makes it authoritative: the durable status
+            // is at least needs_project (company known, no project), needs_task
+            // (project, no task), or bound (project + task) — mirroring
+            // acknowledgedStatus() in state.ts. Never downgrade an acked company to a
+            // pre-threshold "unresolved" projection; that is what dropped the tenant.
+            const ackedClassification = projectId && taskId
+                ? "bound"
+                : projectId
+                    ? "needs_task"
+                    : "needs_project";
             writeSessionState(mergeLocalSessionFields({
                 contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
                 sessionId,
                 companyUid: resolvedCompany.uid,
                 companySlug: resolvedCompany.slug,
-                contextStatus: "bound",
-                projectId,
-                taskId,
-                bindingEpisodeId: delivered.receiptId,
+                contextStatus: bound ? "bound" : ackedClassification,
+                ...(projectId ? { projectId } : {}),
+                ...(taskId ? { taskId } : {}),
                 updatedAt: nowFn().toISOString(),
                 startedAt,
                 ...(typeof toolWrites === "number" ? { toolWrites } : {}),
                 ...(hasTurn ? { hasTurn: true } : {}),
+                ...bindStateFields,
                 ...transcriptFields,
-            }, prior), deps.root);
+            }, 
+            // Merge against the just-written projection rather than the stale
+            // pre-reconcile snapshot, so device confidence and any receipt
+            // attribution survive.
+            readSessionState(sessionId, deps.root) ?? stateWrite), deps.root);
         }
         const kind = registerClassification === "bound"
             ? "bound"
@@ -603,6 +951,12 @@ export async function reconcileObservation(obs, deps) {
                 : registerClassification === "needs_project"
                     ? "needs_project"
                     : "queued";
+        // Report the episode the session actually holds, never the receipt.
+        const ackedState = readSessionState(sessionId, deps.root);
+        const ackedEpisodeId = ackedState &&
+            !isRegisterReceiptEpisodeId(ackedState.bindingEpisodeId, [delivered.receiptId])
+            ? ackedState.bindingEpisodeId
+            : undefined;
         return {
             result: resultOf({
                 kind: kind === "queued" ? "queued" : kind,
@@ -611,9 +965,11 @@ export async function reconcileObservation(obs, deps) {
                 sessionId,
                 clientOperationId: obs.clientOperationId,
                 companyUid: resolvedCompany.uid,
+                companySlug: resolvedCompany.slug,
                 projectId,
                 taskId,
-                bindingEpisodeId: delivered.receiptId,
+                ...(ackedEpisodeId ? { bindingEpisodeId: ackedEpisodeId } : {}),
+                ...bindResultFields,
             }),
             exitCode: EXIT_OK,
             diagnostics: [...diagnostics, `acked receipt=${delivered.receiptId}`],
@@ -622,7 +978,8 @@ export async function reconcileObservation(obs, deps) {
         };
     }
     if (delivered.retryable) {
-        markOutboxQueued(outboxOp.operationId, deps.root, delivered.code, nowFn);
+        const details = sanitizeOutboxErrorDetails(delivered);
+        markOutboxQueued(outboxOp.operationId, deps.root, delivered.code, nowFn, undefined, details);
         return {
             result: resultOf({
                 kind: "queued",
@@ -634,14 +991,20 @@ export async function reconcileObservation(obs, deps) {
                 projectId,
                 taskId,
                 errorCode: delivered.code,
+                ...details,
+                ...bindResultFields,
             }),
             exitCode: EXIT_OK,
-            diagnostics: [...diagnostics, `transient ${delivered.code}; remains queued`],
+            diagnostics: [
+                ...diagnostics,
+                `transient ${delivered.code}${formatDeliveryDetails(details)}; remains queued`,
+            ],
             statePath,
             outboxOperationId: outboxOp.operationId,
         };
     }
-    markOutboxQuarantined(outboxOp.operationId, deps.root, delivered.code, nowFn);
+    const details = sanitizeOutboxErrorDetails(delivered);
+    markOutboxQuarantined(outboxOp.operationId, deps.root, delivered.code, nowFn, details);
     return {
         result: resultOf({
             kind: "error",
@@ -650,15 +1013,28 @@ export async function reconcileObservation(obs, deps) {
             sessionId,
             clientOperationId: obs.clientOperationId,
             companyUid: resolvedCompany.uid,
+            companySlug: resolvedCompany.slug,
             projectId,
             taskId,
             errorCode: delivered.code,
+            ...details,
+            ...bindResultFields,
         }),
         exitCode: EXIT_OK,
-        diagnostics: [...diagnostics, `quarantined: ${delivered.code}`],
+        diagnostics: [
+            ...diagnostics,
+            `quarantined: ${delivered.code}${formatDeliveryDetails(details)}`,
+        ],
         statePath,
         outboxOperationId: outboxOp.operationId,
     };
 }
+function formatDeliveryDetails(details) {
+    const parts = [
+        details.httpStatus !== undefined ? `HTTP ${details.httpStatus}` : "",
+        details.serverCode ?? "",
+    ].filter(Boolean);
+    return parts.length ? ` (${parts.join(" ")})` : "";
+}
 export { replayOutbox };
 //# sourceMappingURL=reconcile.js.map