@awak-app/simy-cli 0.5.43 → 0.5.45

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 };
+}