@awak-app/simy-cli 0.5.43 → 0.5.45

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,

package/src/sqm/claude-plugin.js

@@ -24,6 +24,7 @@ export async function claudePluginFiles() {
   files.set("hooks/action-association.mjs", await readFile(path.join(SOURCE, "hooks/action-association.mjs"), "utf8"));
   files.set("hooks/workspace-lease.mjs", await readFile(path.join(SOURCE, "hooks/workspace-lease.mjs"), "utf8"));
   files.set("hooks/connection-reminder.mjs", await readFile(path.join(SOURCE, "hooks/connection-reminder.mjs"), "utf8"));
+  files.set("hooks/dev-work.mjs", await readFile(path.join(SOURCE, "hooks/dev-work.mjs"), "utf8"));
   const hooks = JSON.parse(await readFile(path.join(SOURCE, "hooks/hooks.json"), "utf8"));
   delete hooks.hooks.Interrupt; // Codex-only event; Claude interruptions cannot be vetoed.
   hooks.hooks.StopFailure = structuredClone(hooks.hooks.Stop);