@awak-app/simy-cli 0.5.43 → 0.5.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.43",
+  "version": "0.5.44",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -37,7 +37,7 @@
     "test:e2e:console:real-provider": "node ./scripts/real-provider-console-e2e.js",
     "test:e2e:console:fullstack": "node ./scripts/fullstack-cli-smoke.js",
     "check": "npm run check:auto-update && node --check ./src/desktop-executor.js && node --check ./src/local-task.js && node --check ./scripts/desktop-executor-e2e.js && node --check ./scripts/pre-guardrail-e2e.js && node --check ./scripts/fixtures/fake-desktop-provider.js && npm run check:syntax && npm run check:session-supervision-syntax && npm run check:real-provider-syntax && npm test && npm run check:package",
-    "check:session-supervision-syntax": "node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs",
+    "check:session-supervision-syntax": "node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/session-supervision/association-store.js && node --check ./src/session-supervision/action-deadline.js && node --check ./src/session-supervision/action-deadline-store.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs",
     "check:auto-update": "node --check ./src/auto-update.js && node --check ./scripts/auto-update-e2e.js && npm run check:sqm",
     "check:workflow-observation-sender": "node --check ./src/workflow-observation-sender.js",
     "check:sqm": "node --check ./src/sqm/canonical.js && node --check ./src/sqm/validation.js && node --check ./src/sqm/reliability.js && node --check ./src/sqm/repository.js && node --check ./src/sqm/checkers.js && node --check ./src/sqm/bundle-store.js && node --check ./src/sqm/proof.js && node --check ./src/sqm/evidence-client.js && node --check ./src/sqm/session.js && node --check ./src/sqm/index.js && node --check ./src/sqm/command.js && node --check ./src/sqm/agent-skill.js && node --check ./src/sqm/workflow-onboarding.js && node --check ./src/sqm/workflow-update.js && node --check ./src/sqm/review-worker.js && node --check ./scripts/sqm-complete-loop-e2e.js && node --check ./scripts/sqm-local-review-e2e.js",

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.5.43";
+export const CLI_VERSION = "0.5.44";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/codex-plugins/simy/hooks/delivery-loop.mjs

@@ -357,6 +357,10 @@ export async function startDelivery({ root = rootDirectory(), provider, session,
     if (previous.run) throw new Error('This session already has a Delivery Loop. Resume or stop it; budgets cannot be reset by starting again.');
     const managedState = managedSpec(managed, session, provider, previous.process, admitted ? admission : null, now);
     if (autoContinueEpoch && managedState) managedState.autoContinueEpoch = autoContinueEpoch;
+    if (managedState && previous.associationTaskId) {
+      managedState.taskId = previous.associationTaskId;
+      if (previous.actionAssociation) managedState.actionAssociation = structuredClone(previous.actionAssociation);
+    }
     if (liveHookAdmission && managedState) managedState.liveHookOwner = { pid: liveHookAdmission.pid,
       identity: liveHookAdmission.identity, hookStartedAt: liveHookAdmission.hookStartedAt };
     const waiting = managedState?.decision?.outcome === 'wait';

package/src/desktop-host.js

@@ -1,3 +1,4 @@
+import { createActionDeadlineService } from './session-supervision/action-deadline.js';
 import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
 import { controlDelivery, verifyDelivery } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
 import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
@@ -48,8 +49,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
   const lock = candidate ? null : await acquireDesktopProcessLock(root, { webOrigin });
   const supervisorToken = lock?.nonce || env.SIMY_DESKTOP_SUPERVISOR_TOKEN;
   let agent, updater, analysisManager, automaticContinuation, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null, publishAgain = false;
-  const makeActionAssociations = () => (dependencies.createActionAssociationHost || createActionAssociationHost)({ root: join(root, "delivery-hooks"), sessionRoot: root, webOrigin });
+  const makeActionAssociations = () => (dependencies.createActionAssociationHost || createActionAssociationHost)({ root: join(root, "delivery-hooks"), sessionRoot: root, webOrigin, onChange: () => { if (!closed) setImmediate(() => { void publish().catch(() => {}); }); } });
   let actionAssociations = makeActionAssociations();
+  const deadlines = createActionDeadlineService({ root: join(root, "action-deadlines") });
   const managedSupervisor = (dependencies.createManagedSupervisor || createManagedSupervisor)({ root: join(root, "delivery-hooks"),
     beforeClaim: record => actionAssociations.prepareCached?.(record) || record });
   let shuttingDown = null;
@@ -105,7 +107,16 @@ export async function startDesktopHost({ input = process.stdin, output = process
       await actionAssociations.decorate(status.deliveryHooks);
       const discovery = refreshSessions();
       automaticContinuation?.tick(discovery.sessions);
-      status.sessionSupervision = { ...discovery, sessions: discovery.sessions.map(candidate => automaticContinuation.project(analysisManager.project(candidate))) };
+      const sessions = discovery.sessions.map(candidate => automaticContinuation.project(analysisManager.project(candidate)));
+      await actionAssociations.decorateSessions?.(sessions);
+      for (const session of sessions) {
+        const context = await actionAssociations.deadlineContext?.(session);
+        if (context) session.actionDeadline = await deadlines.reconcile(context);
+        else session.actionDeadline = { status: 'unavailable', online: false, reminder: null };
+        const run = status.deliveryHooks.runs?.find(item => item.provider === session.provider && item.session === session.session);
+        if (run) run.actionDeadline = session.actionDeadline;
+      }
+      status.sessionSupervision = { ...discovery, sessions };
       if (!closed && !relay) emit({ type: "status", status });
     }).finally(() => { publishing = null; if (publishAgain && !closed) { publishAgain = false; setImmediate(() => { void publish().catch(() => {}); }); } });
     return publishing;
@@ -301,7 +312,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await verifyDelivery({ root: join(root, "delivery-hooks"), provider: command.provider, session: command.session,
             taskId: command.taskId, criterionId: command.criterionId });
         } else if (["session_action_select", "session_action_unlink", "session_action_refresh"].includes(action)) {
-          await actionAssociations.correct(command);
+          const candidate = await selectedSession(command);
+          await actionAssociations.correct(command, analysisManager.project(candidate));
         } else if (action === "session_set_auto_continue") {
           if (typeof command.enabled !== 'boolean') throw new Error('Choose whether automatic continuation is enabled.');
           if (command.enabled) {
@@ -316,6 +328,17 @@ export async function startDesktopHost({ input = process.stdin, output = process
             const fresh = await selectedSession(command);
             if (fresh.capabilities?.canAnalyze === true) await analysisManager.request(fresh);
           }
+        } else if (action === "session_deadline_decide") {
+          if (command.cancel === true) { emit({ type: "result", id: command.id, ok: true }); return; }
+          const candidate = await selectedSession(command);
+          await actionAssociations.correct({ ...command, action: 'session_action_refresh' }, analysisManager.project(candidate));
+          const projected = analysisManager.project(candidate);
+          await actionAssociations.decorateSessions?.([projected]);
+          const context = await actionAssociations.deadlineContext?.(projected);
+          if (!context || context.taskId !== command.taskId) throw new Error('Refresh this conversation before deciding its deadline.');
+          await deadlines.reconcile(context);
+          const result = await deadlines.decide(context, { ...command, requestId: command.requestId || command.decisionId });
+          if (result.status === 'conflict') throw Object.assign(new Error('Deadline changed; refresh before deciding.'), { code: 'conflict' });
         } else if (action === "session_track" || action === "session_untrack") {
           const candidate = await selectedSession(command);
           if (candidate.capabilities?.canMonitor !== true) throw new Error('Tracking is unavailable for this conversation.');

package/src/session-supervision/action-association-host.js

@@ -1,3 +1,4 @@
+import { createOrdinaryAssociationStore } from './association-store.js';
 import { listRecords, updateRecord, TERMINAL, managedBudgetReason } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { createActionAssociationApi, ActionAssociationApiError } from './action-association-api.js';
 import { actionCandidateRequest, prepareActionAssociation, importActionBinding,
@@ -14,8 +15,9 @@ const hardFailure = code => ['unauthorized', 'unavailable', 'invalid_request', '
 // Association is optional metadata. Network failures never control the task's
 // work state; provider turns and their budgets remain owned by the supervisor.
 export function createActionAssociationHost({ root, sessionRoot, webOrigin, api = createActionAssociationApi({ webOrigin, sessionRoot }),
-  now = Date.now, refreshMs = 60_000, list = listRecords } = {}) {
+  now = Date.now, refreshMs = 60_000, list = listRecords, onChange = () => {} } = {}) {
   const abort = new AbortController(), views = new Map();
+  const ordinary = createOrdinaryAssociationStore({ root, api, webOrigin, now, onChange });
   let auth = null, closed = false, running = null, serial = Promise.resolve();
   const enqueue = work => {
     const result = serial.then(work); serial = result.catch(() => {}); return result;
@@ -144,6 +146,34 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
     }));
   }
   return {
+    async decorateSessions(sessions) {
+      await ordinary.decorate(sessions);
+      const records = await list(root);
+      const status = { runs: sessions.filter(item => records.some(record => record.provider === item.provider && record.session === item.session && record.run?.managed)).map(item => {
+        const record = records.find(record => record.provider === item.provider && record.session === item.session);
+        return { managed: true, taskId: record.run.managed.taskId, actionAssociation: record.run.managed.actionAssociation, candidate: item };
+      }) };
+      await this.decorate(status);
+      for (const run of status.runs) run.candidate.actionAssociation = run.actionAssociation;
+      return sessions;
+    },
+    async deadlineContext(candidate) {
+      const expected = await current(), record = (await list(root)).find(item => item.provider === candidate.provider && item.session === candidate.session);
+      const local = record?.run?.managed?.actionAssociation || record?.actionAssociation;
+      if (!expected || local?.authRevision !== expected || !candidate.actionAssociation?.canCorrect) return null;
+      const binding = candidate.actionAssociation.binding;
+      const fingerprint = value => JSON.stringify([value?.revision, value?.action?.id, value?.action?.revision, value?.action?.dueAt, value?.action?.timeZone, value?.action?.status]);
+      return { namespace: local.namespace, provider: candidate.provider, session: candidate.session, taskId: candidate.taskId, binding,
+        taskStatus: null, remainingWork: record.run?.managed?.sessionUnderstanding?.remaining || record.run?.managed?.remainingWork || candidate.analysis?.remaining || candidate.analysis?.remainingWork || null,
+        plan: record.run?.managed?.plan || candidate.analysis?.plan || null, blocker: record.run?.blocker || candidate.analysis?.blocker || null, online: true,
+        validate: async () => {
+          if (!await valid(expected)) return false;
+          const latest = (await list(root)).find(item => item.provider === candidate.provider && item.session === candidate.session);
+          const scoped = latest?.run?.managed?.actionAssociation || latest?.actionAssociation;
+          return (latest?.run?.managed?.taskId || latest?.associationTaskId) === candidate.taskId && scoped?.namespace === local.namespace && scoped?.authRevision === expected && fingerprint(scoped.binding) === fingerprint(binding);
+        } };
+
+    },
     async prepareCached(record) {
       const view = views.get(record?.run?.managed?.taskId), request = actionCandidateRequest(record);
       if (closed || !auth || !view || view.auth !== auth || view.error || !view.snapshot || !request || view.contextRevision !== request.context.revision || view.snapshot.contextRevision !== request.context.revision || view.namespace !== namespaceFor(webOrigin, view.snapshot.scope)) return record;
@@ -170,7 +200,7 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
             status: view.error || local?.status || 'waiting_boundary',
             binding: view.namespace && local?.namespace === view.namespace ? publicBinding(local.binding) : null,
             candidates: (view.candidates || []).slice(0,5), canCorrect: !view.error,
-            retryOn: local?.retryOn || null, truncated: view.candidateTruncated || false,
+            contextRevision: view.contextRevision, candidateRevision: view.snapshot?.candidateRevision || null, retryOn: local?.retryOn || null, truncated: view.candidateTruncated || false,
           };
         let bytes = Buffer.byteLength(JSON.stringify(run.actionAssociation));
         if (bytes > Math.min(remainingBytes,perRunBytes)) { run.actionAssociation.candidates = []; run.actionAssociation.truncated = true; bytes = Buffer.byteLength(JSON.stringify(run.actionAssociation)); }
@@ -183,7 +213,8 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
       }
       return status;
     },
-    correct(command) {
+    correct(command, candidate) {
+      if (candidate && candidate.binding?.mode !== 'managed' && candidate.binding?.mode !== 'pending_takeover') return ordinary.correct(command, candidate);
       return enqueue(async () => {
         const expected = await current(), record = await fresh(command);
         if (!expected) throw new ActionAssociationApiError('signed_out');
@@ -192,9 +223,11 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
         const view = views.get(command.taskId);
         if (!await valid(expected) || !view?.namespace || view.error) throw new ActionAssociationApiError(view?.error || 'unavailable');
         if (command.action === 'session_action_refresh') { view.nextRefresh = 0; return; }
+        if (command.expectedContextRevision && command.expectedContextRevision !== view.contextRevision || command.expectedCandidateRevision && command.expectedCandidateRevision !== view.snapshot?.candidateRevision) throw new ActionAssociationApiError('conflict');
         const latest = await fresh(command), binding = latest?.run.managed.actionAssociation?.binding;
         if ((binding?.revision ?? null) !== command.expectedBindingRevision) throw new ActionAssociationApiError('conflict');
         const selected = command.action === 'session_action_select' ? view.snapshot?.candidates.find(item => item.id === command.actionId) || (!view.snapshot && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(command.actionId || '') ? { id: command.actionId, revision: null } : null) : null;
+        if (selected && command.expectedActionRevision && command.expectedActionRevision !== selected.revision) throw new ActionAssociationApiError('conflict');
         if (command.action !== 'session_action_unlink' && !selected) throw new ActionAssociationApiError('invalid_request');
         const envelope = await api.saveBinding(command.taskId, {
           expectedRevision: command.expectedBindingRevision, contextRevision: view.contextRevision,
@@ -208,6 +241,6 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
         view.error = null; view.nextRefresh = 0;
       });
     },
-    async close() { closed = true; abort.abort(); await Promise.allSettled([serial, running]); views.clear(); },
+    async close() { closed = true; abort.abort(); await Promise.allSettled([serial, running, ordinary.close()]); views.clear(); },
   };
 }

package/src/session-supervision/action-deadline-store.js

@@ -0,0 +1,57 @@
+import { mkdir, readFile, writeFile, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+
+// All instances in a host share a queue; every transaction reloads disk so a
+// newly created host sees durable decisions instead of an in-memory snapshot.
+const queues = new Map();
+export function createActionDeadlineStore({ root }) {
+  const directory = join(root, "action-deadlines");
+  const pathFor = (identity) =>
+    join(
+      directory,
+      `${createHash("sha256").update(JSON.stringify(identity)).digest("hex")}.json`,
+    );
+  const read = async (identity) => {
+    try {
+      return JSON.parse(await readFile(pathFor(identity), "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+  };
+  return {
+    read,
+    transact(identity, update, validate = async () => true) {
+      const path = pathFor(identity);
+      const result = (queues.get(path) || Promise.resolve()).then(async () => {
+        const previous = await read(identity);
+        const assertCurrent = async () => {
+          if (!(await validate()))
+            throw Object.assign(new Error("Deadline context changed."), {
+              code: "conflict",
+            });
+        };
+        await assertCurrent();
+        const next = await update(previous);
+        if (next !== previous && next !== undefined) {
+          await mkdir(directory, { recursive: true, mode: 0o700 });
+          const temporary = `${path}.${randomUUID()}.tmp`;
+          await writeFile(temporary, JSON.stringify(next), { mode: 0o600 });
+          try {
+            await assertCurrent();
+            await rename(temporary, path);
+          } finally {
+            await rm(temporary, { force: true });
+          }
+        }
+        return next === undefined ? previous : next;
+      });
+      queues.set(
+        path,
+        result.catch(() => {}),
+      );
+      return result;
+    },
+  };
+}

package/src/session-supervision/action-deadline.js

@@ -0,0 +1,310 @@
+import { createHash } from "node:crypto";
+import { createActionDeadlineStore } from "./action-deadline-store.js";
+
+const terminal = new Set([
+  "completed",
+  "complete",
+  "done",
+  "cancelled",
+  "canceled",
+  "failed",
+  "archived",
+  "deleted",
+]);
+const hash = (value) =>
+  createHash("sha256").update(JSON.stringify(value)).digest("hex");
+const identity = (context) => {
+  const result = [
+    context.namespace,
+    context.provider,
+    context.session,
+    context.taskId,
+  ];
+  if (result.some((value) => typeof value !== "string" || !value))
+    throw new Error("A scoped session and task identity is required.");
+  return result;
+};
+// A date-only Action is due at the next local midnight, including DST days.
+// Explicit timestamps must carry their own offset; host local timezone is never used.
+export function actionDueInstant(dueAt, timeZone) {
+  if (typeof dueAt !== "string") return null;
+  try {
+    if (/^\d{4}-\d{2}-\d{2}$/.test(dueAt)) {
+      if (typeof timeZone !== "string" || !timeZone) return null;
+      const format = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+      });
+      const start = Date.parse(`${dueAt}T00:00:00Z`);
+      if (
+        !Number.isFinite(start) ||
+        new Date(start).toISOString().slice(0, 10) !== dueAt
+      )
+        return null;
+      const localDate = (instant) => {
+        const parts = Object.fromEntries(
+          format.formatToParts(instant).map((part) => [part.type, part.value]),
+        );
+        return `${parts.year}-${parts.month}-${parts.day}`;
+      };
+      let low = start - 36 * 3600000,
+        high = start + 60 * 3600000;
+      while (high - low > 1) {
+        const mid = Math.floor((low + high) / 2);
+        if (localDate(mid) <= dueAt) low = mid;
+        else high = mid;
+      }
+      return high;
+    }
+    if (!/^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d{2}:\d{2})$/i.test(dueAt))
+      return null;
+    const calendar = dueAt.slice(0, 10),
+      calendarInstant = Date.parse(`${calendar}T00:00:00Z`);
+    if (
+      !Number.isFinite(calendarInstant) ||
+      new Date(calendarInstant).toISOString().slice(0, 10) !== calendar
+    )
+      return null;
+    const instant = Date.parse(dueAt);
+    return Number.isFinite(instant) ? instant : null;
+  } catch {
+    return null;
+  }
+}
+const options = [
+  {
+    id: "keep_scope",
+    title: "Keep the current scope",
+    description: "Continue the remaining work with the current deadline.",
+  },
+  {
+    id: "revise_deadline",
+    title: "Propose a new deadline",
+    description: "Discuss a new deadline before changing the Action.",
+  },
+  {
+    id: "reduce_scope",
+    title: "Propose a smaller scope",
+    description: "Discuss what to defer before changing the Action.",
+  },
+];
+export function createActionDeadlineService({
+  root,
+  now = Date.now,
+  store = createActionDeadlineStore({ root }),
+  reminderLeadMs = 24 * 3600000,
+} = {}) {
+  const transact = async (context, update) => {
+    try {
+      return await store.transact(
+        identity(context),
+        update,
+        context.validate || context.isCurrent,
+      );
+    } catch (error) {
+      if (error.code === "conflict")
+        return {
+          status: "conflict",
+          reminder: null,
+          decision: null,
+          httpStatus: 409,
+        };
+      throw error;
+    }
+  };
+  const view = (state, context) => ({
+    ...state,
+    online: context.online !== false,
+    remoteApplied: false,
+    persistence: "local",
+    options,
+    remainingWork: context.remainingWork ?? null,
+    blocker: context.blocker ?? null,
+    plan: context.plan ?? null,
+    recommendation: {
+      optionId: context.blocker ? "revise_deadline" : "keep_scope",
+      rationale: context.blocker
+        ? "Resolve the blocker and discuss a realistic deadline."
+        : "Continue the known remaining work; no completion forecast is available.",
+    },
+  });
+  async function reconcile(context) {
+    const key = identity(context),
+      action = context.binding?.action;
+    const dueInstant = actionDueInstant(action?.dueAt, action?.timeZone);
+    const bindingRevision =
+      context.binding?.revision ?? context.bindingRevision ?? null;
+    const fingerprint = hash([
+      action?.id,
+      action?.revision,
+      bindingRevision,
+      action?.dueAt,
+      action?.timeZone,
+      action?.status,
+      terminal.has(context.taskStatus),
+    ]);
+    const state = await transact(context, (previous) => {
+      if (context.online === false) return previous;
+      // Tombstones retain the last authoritative revision, so old snapshots
+      // cannot clear a newer binding or resurrect a previously unlinked Action.
+      if (
+        previous?.bindingRevision != null &&
+        (bindingRevision == null
+          ? !(context.validate || context.isCurrent)
+          : previous.bindingRevision > bindingRevision)
+      )
+        return previous;
+      if (previous?.fingerprint === fingerprint) return previous;
+      const revision = (previous?.revision || 0) + 1;
+      const base = {
+        identity: key,
+        fingerprint,
+        revision,
+        bindingRevision: bindingRevision ?? previous?.bindingRevision ?? null,
+        actionId: action?.id ?? null,
+        actionRevision: action?.revision ?? null,
+        dueAt: action?.dueAt ?? null,
+        timeZone: action?.timeZone ?? null,
+        reminder: null,
+        decision: null,
+      };
+      if (
+        !action ||
+        terminal.has(action.status) ||
+        terminal.has(context.taskStatus)
+      )
+        return { ...base, status: "hidden" };
+      if (action.dueAt == null || action.dueAt === "") return { ...base, status: "hidden" };
+      if (dueInstant === null)
+        return {
+          ...base,
+          status: "unavailable",
+          reason: "The Action deadline needs a valid date and timezone.",
+        };
+      return {
+        ...base,
+        dueInstant,
+        status: "upcoming",
+        reminder: {
+          key: hash([...key, fingerprint]),
+          revision,
+          dueAt: action.dueAt,
+          timeZone: action.timeZone,
+          dueInstant,
+        },
+      };
+    });
+    return project(state, context);
+  }
+  function project(state, context) {
+    if (!state)
+      return view(
+        {
+          status: context.online === false ? "unavailable" : "hidden",
+          reminder: null,
+          decision: null,
+        },
+        context,
+      );
+    const status =
+      context.online === false
+        ? "unavailable"
+        : state.decision
+          ? "decided"
+          : state.reminder && now() >= state.dueInstant
+            ? "overdue"
+            : state.reminder && now() >= state.dueInstant - reminderLeadMs
+              ? "due"
+              : state.status;
+    return view({ ...state, status }, context);
+  }
+  // Saving a local choice does not edit the remote Action deadline or scope.
+  async function decide(context, payload) {
+    const key = identity(context);
+    if (payload.cancel === true)
+      return { ...(await read(context)), cancelled: true };
+    let conflict = false;
+    const state = await transact(context, (previous) => {
+      const action = context.binding?.action;
+      if (
+        context.online === false ||
+        !previous?.reminder ||
+        terminal.has(context.taskStatus) ||
+        terminal.has(action?.status) ||
+        previous.reminder.key !== payload.reminderKey ||
+        previous.reminder.revision !== payload.reminderRevision ||
+        previous.actionId !== action?.id ||
+        (payload.actionId && payload.actionId !== action.id) ||
+        previous.actionRevision !== action?.revision ||
+        previous.actionRevision !== payload.expectedActionRevision ||
+        previous.bindingRevision !== context.binding?.revision ||
+        previous.bindingRevision !== payload.expectedBindingRevision ||
+        previous.dueAt !== action?.dueAt ||
+        previous.timeZone !== action?.timeZone
+      ) {
+        conflict = true;
+        return previous;
+      }
+      const requestId = payload.requestId || payload.decisionId;
+      if (
+        typeof requestId !== "string" ||
+        !requestId ||
+        !options.some((option) => option.id === payload.choice)
+      ) {
+        conflict = true;
+        return previous;
+      }
+      const payloadRevision = hash([
+        payload.actionId ?? null,
+        payload.reminderKey,
+        payload.reminderRevision,
+        payload.expectedActionRevision,
+        payload.expectedBindingRevision,
+        payload.choice,
+        payload.expectedDecisionRevision ?? null,
+      ]);
+      if (Object.hasOwn(previous.requests || {}, requestId)) {
+        if (previous.requests[requestId].payloadRevision !== payloadRevision)
+          conflict = true;
+        return previous;
+      }
+      if (previous.decision?.requestId === requestId) {
+        if (previous.decision.choice !== payload.choice) conflict = true;
+        return previous;
+      }
+      if (
+        previous.decision &&
+        payload.expectedDecisionRevision !== previous.decision.revision
+      ) {
+        conflict = true;
+        return previous;
+      }
+      return {
+        ...previous,
+        status: "decided",
+        requests: {
+          ...previous.requests,
+          [requestId]: { choice: payload.choice, payloadRevision },
+        },
+        decision: {
+          id: requestId,
+          requestId,
+          choice: payload.choice,
+          revision: (previous.decision?.revision || 0) + 1,
+          reminderKey: previous.reminder.key,
+          createdAt: now(),
+          remoteApplied: false,
+        },
+      };
+    });
+    return conflict
+      ? { ...project(state, context), status: "conflict", httpStatus: 409 }
+      : project(state, context);
+  }
+  async function read(context) {
+    return project(await store.read(identity(context)), context);
+  }
+  return { reconcile, read, decide };
+}

package/src/session-supervision/association-store.js

@@ -0,0 +1,369 @@
+import { randomUUID } from 'node:crypto';
+import {
+  listRecords,
+  updateRecord,
+} from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { associationRevision } from './action-association.js';
+import { ActionAssociationApiError } from './action-association-api.js';
+
+export const sessionAssociationContext = (candidate) => {
+  const grounded =
+    candidate.analysis?.state === 'continue' &&
+    candidate.analysis?.basis?.some((item) => item.role === 'user');
+  const objective =
+    ((grounded && candidate.analysis.objective) || candidate.title || '').slice(
+      0,
+      1000,
+    ) || 'Selected conversation';
+  const context = {
+    objective,
+    deliverables: grounded
+      ? (candidate.analysis.remaining || []).slice(0, 8)
+      : [],
+    projectHints: [],
+    repositoryUrls: [],
+    relatedUrls: [],
+    actionIds: [],
+    sourceRefs: [],
+    basis: [],
+  };
+  return {
+    ...context,
+    revision: associationRevision({
+      ...context,
+      provider: candidate.provider,
+      session: candidate.session,
+      cwd: candidate.cwd,
+    }),
+  };
+};
+const namespaceFor = (origin, scope) =>
+  JSON.stringify([new URL(origin).origin, scope.organizationId, scope.userId]);
+
+// This store grants no continuation authority. Only validated discovery metadata
+// can create identities; record locks serialize identity creation and corrections.
+export function createOrdinaryAssociationStore({
+  root,
+  api,
+  webOrigin,
+  now = Date.now,
+  onChange = () => {},
+}) {
+  const inFlight = new Map();
+  const views = new Map(),
+    abort = new AbortController();
+  let serial = Promise.resolve(),
+    closed = false;
+  const find = async (candidate) =>
+    (await listRecords(root)).find(
+      (item) =>
+        item.provider === candidate.provider &&
+        item.session === candidate.session,
+    );
+  async function ensure(candidate, known) {
+    if (
+      !['codex', 'claude'].includes(candidate.provider) ||
+      !candidate.session ||
+      !candidate.cwd
+    )
+      throw new ActionAssociationApiError('invalid_request');
+    const existing = known === undefined ? await find(candidate) : known;
+    if (existing?.associationTaskId && existing.cwd === candidate.cwd)
+      return existing;
+    return updateRecord(
+      root,
+      candidate.provider,
+      candidate.session,
+      (previous) => {
+        if (previous && previous.cwd !== candidate.cwd)
+          throw new ActionAssociationApiError('conflict');
+        const record = previous || {
+          schemaVersion: 1,
+          provider: candidate.provider,
+          session: candidate.session,
+          cwd: candidate.cwd,
+          run: null,
+        };
+        record.associationTaskId ||=
+          record.run?.managed?.taskId || randomUUID();
+        return record;
+      },
+    );
+  }
+  async function sync(candidate, force = false, known) {
+    const task = candidate.taskId || known?.associationTaskId;
+    if (inFlight.has(task)) await inFlight.get(task);
+    if (closed) return;
+    const record = known || (await ensure(candidate)),
+      taskId = record.run?.managed?.taskId || record.associationTaskId;
+    candidate.taskId = taskId;
+    candidate.binding = { ...candidate.binding, taskId };
+    if (record.run?.managed) return;
+    const auth = await api.authRevision(),
+      context = sessionAssociationContext(candidate);
+    let view = views.get(taskId);
+    if (!auth) {
+      views.set(taskId, { auth, status: 'signed_out' });
+      return;
+    }
+    if (
+      !force &&
+      view?.auth === auth &&
+      view.contextRevision === context.revision &&
+      now() < view.nextRefresh
+    )
+      return;
+    view = {
+      auth,
+      contextRevision: context.revision,
+      status: 'loading',
+      nextRefresh: now() + 15000,
+    };
+    views.set(taskId, view);
+    try {
+      const snapshot = await api.candidates(
+        { taskId, context, limit: 10 },
+        { signal: abort.signal },
+      );
+      if (closed || (await api.authRevision()) !== auth)
+        throw new ActionAssociationApiError('account_changed');
+      if (
+        snapshot.taskId !== taskId ||
+        snapshot.contextRevision !== context.revision ||
+        (snapshot.binding && snapshot.binding.taskId !== taskId)
+      )
+        throw new ActionAssociationApiError('invalid_response');
+      const namespace = namespaceFor(webOrigin, snapshot.scope);
+      const persisted = await updateRecord(
+        root,
+        candidate.provider,
+        candidate.session,
+        (latest) => {
+          if (latest.associationTaskId !== taskId || latest.run?.managed)
+            return latest;
+          if (
+            latest.actionAssociation?.namespace === namespace &&
+            (latest.actionAssociation.binding?.revision || 0) >
+              (snapshot.binding?.revision || 0)
+          )
+            return latest;
+          latest.actionAssociation = {
+            namespace,
+            authRevision: auth,
+            binding: snapshot.binding || null,
+            contextRevision: context.revision,
+            status: snapshot.binding?.action
+              ? 'bound'
+              : snapshot.binding
+                ? 'unlinked'
+                : 'no_match',
+          };
+          return latest;
+        },
+      );
+      if (
+        persisted?.actionAssociation?.namespace === namespace &&
+        (persisted.actionAssociation.binding?.revision || 0) >
+          (snapshot.binding?.revision || 0)
+      )
+        snapshot.binding = persisted.actionAssociation.binding;
+      Object.assign(view, {
+        namespace,
+        snapshot,
+        status: snapshot.binding?.action
+          ? 'bound'
+          : snapshot.binding
+            ? 'unlinked'
+            : 'no_match',
+      });
+    } catch (error) {
+      view.status = error.code || 'offline';
+      view.snapshot = null;
+    }
+  }
+  return {
+    async decorate(sessions) {
+      const records = new Map(
+        (await listRecords(root)).map((record) => [
+          `${record.provider}:${record.session}`,
+          record,
+        ]),
+      );
+      const auth = await api.authRevision();
+      for (const candidate of sessions) {
+        const record = await ensure(
+            candidate,
+            records.get(`${candidate.provider}:${candidate.session}`) || null,
+          ),
+          taskId = record.run?.managed?.taskId || record.associationTaskId;
+        candidate.taskId = taskId;
+        candidate.binding = { ...candidate.binding, taskId };
+        if (record.run?.managed) continue;
+        const cached = views.get(taskId),
+          context = sessionAssociationContext(candidate);
+        if (
+          auth &&
+          !closed &&
+          inFlight.size < 3 &&
+          !inFlight.has(taskId) &&
+          (!cached ||
+            cached.auth !== auth ||
+            cached.contextRevision !== context.revision ||
+            now() >= cached.nextRefresh)
+        ) {
+          const work = sync(candidate, false, record)
+            .catch(() => {})
+            .finally(() => {
+              inFlight.delete(taskId);
+              if (!closed) onChange();
+            });
+          inFlight.set(taskId, work);
+        }
+        const view = views.get(taskId);
+        const snapshot = view?.auth === auth && auth ? view.snapshot : null;
+        const binding = snapshot?.binding;
+        candidate.actionAssociation = {
+          status: !auth ? 'signed_out' : view?.status || 'loading',
+          binding: binding
+            ? {
+                ...binding,
+                evidence: [],
+                reason: (binding.reason || '').slice(0, 60),
+                coveredWork: (binding.coveredWork || '').slice(0, 60),
+                action: binding.action
+                  ? {
+                      ...binding.action,
+                      title: (binding.action.title || '').slice(0, 120),
+                      description: null,
+                    }
+                  : null,
+              }
+            : null,
+          candidates: (snapshot?.candidates || []).slice(0, 5).map((item) => ({
+            id: item.id,
+            revision: item.revision,
+            title: item.title.slice(0, 120),
+          })),
+          canCorrect: Boolean(snapshot),
+          contextRevision: view?.contextRevision || null,
+          candidateRevision: snapshot?.candidateRevision || null,
+          truncated: (snapshot?.candidates?.length || 0) > 5,
+        };
+      }
+      return sessions;
+    },
+    correct(command, candidate) {
+      const work = serial.then(async () => {
+        const before = await find(candidate);
+        if (
+          !before ||
+          before.associationTaskId !== command.taskId ||
+          before.run?.managed
+        )
+          throw new ActionAssociationApiError('invalid_request');
+        const auth = await api.authRevision();
+        if (!auth) throw new ActionAssociationApiError('signed_out');
+        await sync(candidate, true);
+        const view = views.get(command.taskId);
+        if (
+          !view?.snapshot ||
+          view.auth !== auth ||
+          (await api.authRevision()) !== auth
+        )
+          throw new ActionAssociationApiError(
+            view?.status || 'account_changed',
+          );
+        if (command.action === 'session_action_refresh') return;
+        if (
+          (command.expectedContextRevision || command.contextRevision) &&
+          (command.expectedContextRevision || command.contextRevision) !==
+            view.contextRevision
+        )
+          throw new ActionAssociationApiError('conflict');
+        const snapshot = view.snapshot,
+          selected =
+            command.action === 'session_action_select'
+              ? snapshot.candidates.find((item) => item.id === command.actionId)
+              : null;
+        if (command.action !== 'session_action_unlink' && !selected)
+          throw new ActionAssociationApiError('invalid_request');
+        if (
+          (command.expectedCandidateRevision &&
+            command.expectedCandidateRevision !== snapshot.candidateRevision) ||
+          (selected &&
+            command.expectedActionRevision &&
+            command.expectedActionRevision !== selected.revision)
+        )
+          throw new ActionAssociationApiError('conflict');
+        const binding = snapshot.binding;
+        // Retransmitting the same click is successful without a second write.
+        if (
+          binding?.origin === 'user' &&
+          (binding.action?.id || null) === (selected?.id || null)
+        )
+          return;
+        if ((binding?.revision ?? null) !== command.expectedBindingRevision)
+          throw new ActionAssociationApiError('conflict');
+        try {
+          const saved = await api.saveBinding(
+            command.taskId,
+            {
+              expectedRevision: command.expectedBindingRevision,
+              contextRevision: view.contextRevision,
+              candidateRevision: snapshot.candidateRevision,
+              origin: 'user',
+              actionId: selected?.id || null,
+              actionRevision: selected?.revision || null,
+              relation: selected ? 'part_of' : null,
+              coveredWork: sessionAssociationContext(candidate).objective,
+              reason: selected
+                ? 'Selected by the user.'
+                : 'Unlinked by the user.',
+              evidence: [],
+            },
+            { signal: abort.signal },
+          );
+          if (
+            (await api.authRevision()) !== auth ||
+            namespaceFor(webOrigin, saved.scope) !== view.namespace ||
+            saved.binding?.taskId !== command.taskId
+          )
+            throw new ActionAssociationApiError('account_changed');
+          await updateRecord(
+            root,
+            candidate.provider,
+            candidate.session,
+            (latest) => {
+              if (
+                latest.associationTaskId !== command.taskId ||
+                latest.run?.managed
+              )
+                throw new ActionAssociationApiError('conflict');
+              latest.actionAssociation = {
+                namespace: view.namespace,
+                authRevision: auth,
+                binding: saved.binding,
+                contextRevision: view.contextRevision,
+                status: saved.binding.action ? 'bound' : 'unlinked',
+              };
+              return latest;
+            },
+          );
+          view.nextRefresh = 0;
+        } catch (error) {
+          view.nextRefresh = 0;
+          if (error.code === 'conflict') await sync(candidate, true);
+          throw error;
+        }
+      });
+      serial = work.catch(() => {});
+      return work;
+    },
+    async close() {
+      closed = true;
+      abort.abort();
+      await Promise.allSettled([serial, ...inFlight.values()]);
+      views.clear();
+    },
+  };
+}

package/src/session-supervision/index.js

@@ -91,7 +91,8 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       autoContinueEpoch: record?.autoContinue === true ? record.autoContinueEpoch : null,
       ...autoContinueState(record, isRunning, supported || liveHook),
       lastActivityAt: item.lastActivityAt, observation: item.observation, availability: item.availability,
-      binding: { mode, taskId: run?.managed?.taskId || null },
+      taskId: run?.managed?.taskId || record?.associationTaskId || null,
+      binding: { mode, taskId: run?.managed?.taskId || record?.associationTaskId || null },
       originalSessionTarget: originalSessionTarget(item.provider, item.session),
       continuationMode: item.provider === 'claude' ? liveHook ? 'live_hook' : 'manual' : supported ? 'codex_app_server' : 'manual',
       capabilities: { canMonitor: item.capabilities?.canMonitor ?? true,