@awak-app/simy-cli 0.5.42 → 0.5.44

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();
+    },
+  };
+}