@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

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

@@ -5,17 +5,13 @@
 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, listOutboxOperations, markOutboxAcked, markOutboxQuarantined, markOutboxQueued, replayOutbox, writeAckedRegisterState, } from "./outbox.js";
-import { mergeLocalSessionFields, isRegisterReceiptEpisodeId, readSessionState, stripRegisterReceiptEpisodes, writeSessionState, } from "./state.js";
+import { enqueueOutbox, markOutboxAcked, markOutboxQuarantined, markOutboxQueued, replayOutbox, } from "./outbox.js";
+import { mergeLocalSessionFields, readSessionState, writeSessionState, } from "./state.js";
 function resultOf(parts) {
     const out = {
         contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
@@ -28,8 +24,6 @@ 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)
@@ -38,10 +32,6 @@ function resultOf(parts) {
         out.bindingEpisodeId = parts.bindingEpisodeId;
     if (parts.errorCode)
         out.errorCode = parts.errorCode;
-    if (parts.projectBindReason)
-        out.projectBindReason = parts.projectBindReason;
-    if (parts.projectCandidates)
-        out.projectCandidates = parts.projectCandidates;
     return out;
 }
 function parseUntrackedOrigin(obs) {
@@ -174,22 +164,7 @@ export async function reconcileObservation(obs, deps) {
         }
     }
     // Already untracked locally — stay untracked until explicit opt-in (no backfill).
-    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;
+    const prior = readSessionState(sessionId, deps.root);
     if (prior?.contextStatus === "untracked" && prior.untrackedReceipt?.origin === "user") {
         return {
             result: resultOf({
@@ -247,7 +222,6 @@ export async function reconcileObservation(obs, deps) {
         hqRoot,
         remoteOwnerSlug,
         repoIdentityKey,
-        allowDeviceDefault: deps.allowDeviceDefault,
         existingState: prior,
     });
     const nowIso = nowFn().toISOString();
@@ -319,10 +293,12 @@ export async function reconcileObservation(obs, deps) {
             startedAt,
             ...(typeof toolWrites === "number" ? { toolWrites } : {}),
             ...(hasTurn ? { hasTurn: true } : {}),
-            // Preserve prior scope for visibility; its receipt belongs to the
-            // quarantined binding and must not suppress a later retry.
+            // Preserve prior binding ids for visibility; do not auto-switch.
             ...(prior?.projectId ? { projectId: prior.projectId } : {}),
             ...(prior?.taskId ? { taskId: prior.taskId } : {}),
+            ...(prior?.bindingEpisodeId
+                ? { bindingEpisodeId: prior.bindingEpisodeId }
+                : {}),
             ...transcriptFields,
             decision: {
                 decisionId: `conflict_${sessionId}`,
@@ -349,7 +325,7 @@ export async function reconcileObservation(obs, deps) {
                 askAfter: false,
                 ...(correctionPath ? { correctionPath } : {}),
             },
-        }, prior, { preserveBindingEpisode: false }), deps.root);
+        }, prior), deps.root);
         return {
             result: resultOf({
                 kind: "company_conflict",
@@ -367,63 +343,8 @@ 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 (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)) {
+    if (!resolvedCompany.uid && resolvedCompany.slug && deps.validateMembership) {
         try {
             const membership = await deps.validateMembership(resolvedCompany.slug);
             if (membership && typeof membership === "object" && membership.uid) {
@@ -434,11 +355,7 @@ 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,
@@ -449,10 +366,7 @@ export async function reconcileObservation(obs, deps) {
                     ...(typeof toolWrites === "number" ? { toolWrites } : {}),
                     ...(hasTurn ? { hasTurn: true } : {}),
                     ...transcriptFields,
-                    ...(deniedLeave ? { presenceLeave: deniedLeave } : {}),
-                }, prior, companyBindingChanged(prior, resolvedCompany)
-                    ? { preserveBindingEpisode: false, preserveCompanyBinding: false }
-                    : {}), deps.root);
+                }, prior), deps.root);
                 return {
                     result: resultOf({
                         kind: "needs_company",
@@ -472,39 +386,16 @@ 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: projectPrior,
+        existingState: prior,
     });
     // Deterministic cwd projects belong to the cwd company. A higher-precedence
     // identity UID must not adopt a project from an unrelated/unverified slug.
@@ -514,107 +405,8 @@ export async function reconcileObservation(obs, deps) {
             projectResolved = null;
         }
     }
-    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 } : {}),
-    };
+    const projectId = projectResolved?.projectId;
+    const taskId = projectResolved?.taskId;
     // Trusted / deterministic auto-bind never asks.
     // Transcript-sourced sessions never ask (US-018).
     const fromTranscript = obs.source === "transcript";
@@ -629,10 +421,7 @@ export async function reconcileObservation(obs, deps) {
         (projectResolved.source === "deterministic_cwd" ||
             projectResolved.source === "deterministic_registry"));
     let classification;
-    if (projectGate === "choose") {
-        classification = "needs_project";
-    }
-    else if (autoBound) {
+    if (autoBound) {
         classification = "bound";
     }
     else if (projectId && taskId) {
@@ -693,106 +482,7 @@ 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,
@@ -802,7 +492,6 @@ export async function reconcileObservation(obs, deps) {
             companySlug: resolvedCompany.slug,
             projectId,
             taskId,
-            companyConfidence,
             kind: "register",
             now: nowFn,
         }, deps.root);
@@ -829,14 +518,13 @@ export async function reconcileObservation(obs, deps) {
         diagnostics.push(`project source=${projectResolved.source} projectId=${projectId ?? "-"} taskId=${taskId ?? "-"}`);
     }
     let statePath;
-    let stateWrite;
     try {
-        stateWrite = mergeLocalSessionFields({
+        const stateWrite = mergeLocalSessionFields({
             contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
             sessionId,
             companyUid: resolvedCompany.uid,
             companySlug: resolvedCompany.slug,
-            contextStatus: stateClassification,
+            contextStatus: registerClassification,
             projectId,
             taskId,
             updatedAt: nowIso,
@@ -844,13 +532,8 @@ export async function reconcileObservation(obs, deps) {
             ...(typeof toolWrites === "number" ? { toolWrites } : {}),
             ...(hasTurn ? { hasTurn: true } : {}),
             ...(decision ? { decision } : {}),
-            ...(companyConfidence ? { companyConfidence } : {}),
-            ...(presenceLeave ? { presenceLeave } : {}),
-            ...bindStateFields,
             ...transcriptFields,
-        }, prior, companyRebind
-            ? { preserveBindingEpisode: false, preserveCompanyBinding: false }
-            : {});
+        }, prior);
         statePath = writeSessionState(stateWrite, deps.root);
     }
     catch (err) {
@@ -863,7 +546,6 @@ export async function reconcileObservation(obs, deps) {
                     sessionId,
                     clientOperationId: obs.clientOperationId,
                     companyUid: resolvedCompany.uid,
-                    companySlug: resolvedCompany.slug,
                     projectId,
                     taskId,
                     errorCode: "NOT_TRACKING",
@@ -884,10 +566,8 @@ 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"],
@@ -898,47 +578,23 @@ export async function reconcileObservation(obs, deps) {
     const delivered = await deps.deliver(outboxOp);
     if (delivered.ok) {
         markOutboxAcked(outboxOp.operationId, deps.root, delivered.receiptId, nowFn);
-        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";
+        // Persist binding episode on success for bound registrations.
+        if (registerClassification === "bound") {
             writeSessionState(mergeLocalSessionFields({
                 contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
                 sessionId,
                 companyUid: resolvedCompany.uid,
                 companySlug: resolvedCompany.slug,
-                contextStatus: bound ? "bound" : ackedClassification,
-                ...(projectId ? { projectId } : {}),
-                ...(taskId ? { taskId } : {}),
+                contextStatus: "bound",
+                projectId,
+                taskId,
+                bindingEpisodeId: delivered.receiptId,
                 updatedAt: nowFn().toISOString(),
                 startedAt,
                 ...(typeof toolWrites === "number" ? { toolWrites } : {}),
                 ...(hasTurn ? { hasTurn: true } : {}),
-                ...bindStateFields,
                 ...transcriptFields,
-            }, 
-            // 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);
+            }, prior), deps.root);
         }
         const kind = registerClassification === "bound"
             ? "bound"
@@ -947,12 +603,6 @@ 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,
@@ -961,11 +611,9 @@ export async function reconcileObservation(obs, deps) {
                 sessionId,
                 clientOperationId: obs.clientOperationId,
                 companyUid: resolvedCompany.uid,
-                companySlug: resolvedCompany.slug,
                 projectId,
                 taskId,
-                ...(ackedEpisodeId ? { bindingEpisodeId: ackedEpisodeId } : {}),
-                ...bindResultFields,
+                bindingEpisodeId: delivered.receiptId,
             }),
             exitCode: EXIT_OK,
             diagnostics: [...diagnostics, `acked receipt=${delivered.receiptId}`],
@@ -986,7 +634,6 @@ export async function reconcileObservation(obs, deps) {
                 projectId,
                 taskId,
                 errorCode: delivered.code,
-                ...bindResultFields,
             }),
             exitCode: EXIT_OK,
             diagnostics: [...diagnostics, `transient ${delivered.code}; remains queued`],
@@ -1003,11 +650,9 @@ export async function reconcileObservation(obs, deps) {
             sessionId,
             clientOperationId: obs.clientOperationId,
             companyUid: resolvedCompany.uid,
-            companySlug: resolvedCompany.slug,
             projectId,
             taskId,
             errorCode: delivered.code,
-            ...bindResultFields,
         }),
         exitCode: EXIT_OK,
         diagnostics: [...diagnostics, `quarantined: ${delivered.code}`],