@awak-app/simy-cli 0.6.0 → 0.6.1

package/README.md

@@ -188,6 +188,12 @@ checks the bundled CLI in ChatGPT and Codex apps in system and user Applications
 Claude discovery likewise falls back to a compatible native or Desktop bundle
 when an older PATH installation cannot meet its version requirement.
 
+Use `simy delivery activity --watch` for a read-only local snapshot every minute,
+or add `--json` for one JSON object per sample. It separates execution, waits,
+stops, failures and repeated attempts without new verified outcomes, with task
+identity, agent, reasons and outcome timestamps. Missing evidence is shown as
+unknown; open time is never counted as productive time. See [work activity](docs/work-activity.md).
+
 The plugin also provides an opt-in, hook-based Delivery Loop in the user's existing
 Codex or Claude Code conversation. Install the plugin, review and enable SIMY hooks
 with `/hooks`, then request `/simy:delivery-loop` for the task. Installing or updating

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
     "start": "node ./src/index.js",
     "test": "node --test",
     "test:e2e:console": "node ./scripts/console-e2e.js",
+    "test:e2e:work-activity": "node ./scripts/work-activity-e2e.js",
     "test:e2e:sqm-complete-loop": "node ./scripts/sqm-complete-loop-e2e.js",
     "test:e2e:sqm-local-review": "node ./scripts/sqm-local-review-e2e.js",
     "test:e2e:console:narrow": "CLI_E2E_COLUMNS=78 CLI_E2E_ROWS=40 node ./scripts/console-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.6.0";
+export const CLI_VERSION = "0.6.1";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

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

@@ -689,6 +689,8 @@ function newVerifiedCriterion(run, id, now) {
     managed.verifiedCriterionHistory.push(id);
   } else if (Object.hasOwn(managed.verified, id)) return;
   managed.verifiedRevision += 1;
+  // Unlike the budget baseline, this is never initialized by enrollment/migration.
+  if (!Object.hasOwn(managed.verified, id)) managed.lastOutcomeAt = now;
   managed.lastVerifiedProgressAt = Math.max(managed.lastVerifiedProgressAt ?? run.startedAt, now);
 }
 export async function verifyAutomaticCriteria(record, now) {

package/src/delivery-hooks/activity.js

@@ -0,0 +1,125 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { listRecords, processIdentity } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+export const ACTIVITY_INTERVAL_MS = 60_000;
+const clean = value => typeof value === 'string'
+  ? value.replace(/[\x00-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, ' ').trim() : '';
+const timestamp = (value, now) => Number.isFinite(value) && value >= 0 && value <= now ? value : null;
+const iso = value => value === null ? null : new Date(value).toISOString();
+
+function stateOf(record, now, liveRuntime) {
+  const run = record.run;
+  const state = run?.state;
+  if (['failed', 'stopped', 'completed', 'reported_done'].includes(state)) return state;
+  if (state === 'paused') return 'stopped';
+  if (['blocked', 'verification_pending', 'budget_exhausted'].includes(state)) return 'waiting';
+  const recent = value => timestamp(value, now) !== null && now - value < ACTIVITY_INTERVAL_MS;
+  const runtime = record.runtime;
+  // An open process alone is not execution evidence. A positive hook observation
+  // also needs a matching live identity and a recent timestamp.
+  if (runtime?.isRunning === true && liveRuntime && recent(runtime.observedAt)) return 'running';
+  const attempt = run?.managed?.executionAttempt;
+  if (state === 'auto_resuming' && attempt?.phase === 'dispatching' &&
+      recent(attempt.lastActivityAt)) return 'running';
+  if (state === 'recovery_required') return 'waiting';
+  if (runtime?.isRunning === false && recent(runtime.observedAt)) return 'waiting';
+  if (attempt?.phase === 'claimed' && recent(attempt.claimedAt)) return 'waiting';
+  return 'unknown';
+}
+
+export async function workActivitySnapshot(records, { now = Date.now(), inspectProcess = processIdentity } = {}) {
+  const items = [];
+  for (const record of records) {
+    const run = record.run;
+    if (!run && !record.monitor && !record.tracked) continue;
+    const managed = run?.managed;
+    const runtime = record.runtime;
+    let liveRuntime = false;
+    if (runtime?.isRunning === true && runtime.process?.identity &&
+        timestamp(runtime.observedAt, now) !== null && now - runtime.observedAt < ACTIVITY_INTERVAL_MS) {
+      try { liveRuntime = await inspectProcess(runtime.process.pid) === runtime.process.identity; }
+      catch { /* Unknown identity cannot prove execution. */ }
+    }
+    const executionState = stateOf(record, now, liveRuntime);
+    const lastOutcomeAt = timestamp(managed?.lastOutcomeAt, now);
+    const attempts = Number.isInteger(managed?.noProgress) && managed.noProgress >= 0 ? managed.noProgress : null;
+    const progressState = attempts >= 2 ? 'repeating_without_verified_progress'
+      : lastOutcomeAt !== null ? 'verified_outcome_recorded' : 'unknown';
+    const observed = [record.observedAt, runtime?.observedAt, managed?.executionAttempt?.lastActivityAt]
+      .map(value => timestamp(value, now)).filter(value => value !== null);
+    const observedAt = observed.length ? Math.max(...observed) : null;
+    items.push({
+      taskId: clean(managed?.taskId) || clean(record.associationTaskId) || null,
+      provider: clean(record.provider), session: clean(record.session),
+      agent: `${clean(record.provider)}:${clean(record.session)}`, humanAssignee: null,
+      objective: clean(run?.objective) || null, executionState, recordedState: clean(run?.state) || null,
+      progressState, noProgressAttempts: attempts,
+      lastOutcomeAt: iso(lastOutcomeAt),
+      minutesSinceOutcome: lastOutcomeAt === null ? null : Math.floor((now - lastOutcomeAt) / ACTIVITY_INTERVAL_MS),
+      observedAt: iso(observedAt), observationAgeMinutes: observedAt === null ? null : Math.floor((now - observedAt) / ACTIVITY_INTERVAL_MS),
+      reason: executionState === 'unknown' ? 'No fresh execution observation; activity is unknown.'
+        : clean(run?.reason) || (executionState === 'running' ? 'Recent execution observation.' : 'Provider turn is waiting.'),
+      recordedReason: clean(run?.reason) || null,
+      waitOwner: clean(managed?.dependencyWait?.owner) || null,
+      nextCheck: clean(managed?.dependencyWait?.nextCheck) || null,
+    });
+  }
+  items.sort((a, b) => a.agent.localeCompare(b.agent));
+  return { schemaVersion: 1, sampledAt: new Date(now).toISOString(), intervalMs: ACTIVITY_INTERVAL_MS,
+    measurement: 'point_in_time_observations_not_productive_duration', items };
+}
+
+function wrap(value, width = 78) {
+  const chars = Array.from(value);
+  const lines = [];
+  while (chars.length) lines.push(chars.splice(0, width).join(''));
+  return lines.join('\n');
+}
+
+export function formatWorkActivity(snapshot) {
+  const lines = [`Work activity | ${snapshot.sampledAt}`, 'Sampling: 60s. Observations are not productive time.'];
+  if (!snapshot.items.length) lines.push('No locally recorded tasks or monitored sessions.');
+  for (const item of snapshot.items) {
+    lines.push('', `Task: ${item.taskId || 'unassigned (see session)'}`,
+      `Agent: ${item.agent}`, 'Human assignee: unknown',
+      `State: ${item.executionState} | Progress: ${item.progressState}`,
+      `Last verified outcome: ${item.lastOutcomeAt || 'unknown'}`,
+      `Attempts without new verified outcome: ${item.noProgressAttempts ?? 'unknown'}`,
+      `Last observation: ${item.observedAt || 'unknown'}`,
+      `Reason: ${item.reason}`);
+    if (item.recordedReason && item.recordedReason !== item.reason) lines.push(`Recorded reason: ${item.recordedReason}`);
+    if (item.waitOwner) lines.push(`Waiting on: ${item.waitOwner}`);
+    if (item.nextCheck) lines.push(`Next check: ${item.nextCheck}`);
+  }
+  return lines.map(line => wrap(line)).join('\n');
+}
+
+export async function runActivityCommand(args, { root, output = console.log, now = Date.now,
+  readRecords = listRecords, inspectProcess = processIdentity, wait = delay, signal } = {}) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const key = args[i];
+    if (!['--watch', '--json', '--provider', '--session'].includes(key) || Object.hasOwn(options, key)) {
+      throw new Error('Use delivery activity [--watch] [--json] [--provider codex|claude] [--session ID].');
+    }
+    if (['--watch', '--json'].includes(key)) options[key] = true;
+    else {
+      const value = args[++i];
+      if (!value || value.startsWith('--')) throw new Error(`Missing value for ${key}.`);
+      options[key] = value;
+    }
+  }
+  if (options['--provider'] && !['codex', 'claude'].includes(options['--provider'])) throw new Error('Unsupported provider.');
+  do {
+    if (signal?.aborted) break;
+    const records = (await readRecords(root)).filter(record =>
+      (!options['--provider'] || record.provider === options['--provider']) &&
+      (!options['--session'] || record.session === options['--session']));
+    const snapshot = await workActivitySnapshot(records, { now: now(), inspectProcess });
+    output(options['--json'] ? JSON.stringify(snapshot) : formatWorkActivity(snapshot));
+    if (!options['--watch']) break;
+    try { await wait(ACTIVITY_INTERVAL_MS, undefined, { signal }); }
+    catch (error) { if (error.name === 'AbortError' && signal?.aborted) break; throw error; }
+  } while (!signal?.aborted);
+  return 0;
+}

package/src/delivery-hooks/command.js

@@ -2,6 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { startDelivery, checkpointDelivery, controlDelivery, listRecords, rootDirectory, verifyDelivery } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { continueSession } from '../session-supervision/index.js';
 import { cancelHandoffSession, handoffSession } from '../session-supervision/handoff.js';
+import { runActivityCommand } from './activity.js';
 
 async function readCheckpointInput(input) {
   const chunks = [];
@@ -17,7 +18,9 @@ async function readCheckpointInput(input) {
 
 export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = process.cwd(), input = process.stdin, output = console.log } = {}) {
   const [action, ...args] = argv;
+  if (action === 'activity') return runActivityCommand(args, { root, output });
   if (!action || action === '--help') {
+    output('simy delivery activity [--watch] [--json] [--provider codex|claude] [--session ID] — local observations every 60 seconds; not productive time.');
     output('Progress: --continuation-policy progress [--hard-max-minutes 1440] [--hard-max-continuations 50] [--provider-token-ceiling 15000000 (Codex only)]. Soft thresholds warn; approvals, missing usage and no verified progress still stop.');
     output('simy delivery continuation_policy --provider PROVIDER --session ID --task-id ID --continuation-policy bounded|progress');
     output('simy delivery extend --provider PROVIDER --session ID --task-id ID --hard-max-minutes N|--hard-max-continuations N|--provider-token-ceiling N');

package/src/index.js

@@ -57,6 +57,9 @@ if (!configuredWebOrigin) {
 } else if (dispatchArgv[0] === "doctor") {
   const { runDoctor } = await import("./doctor.js");
   process.exitCode = await runDoctor({ webOrigin: configuredWebOrigin, cliVersion: packageInfo.version });
+} else if (dispatchArgv[0] === "delivery" && dispatchArgv[1] === "activity") {
+  // A local observation must not install updates or require a network connection.
+  await runCommand();
 } else if (dispatchArgv[0] === "update") {
   const checkOnly = args.has("--check");
   const result = await runCliUpdateGate({

package/src/workflow-observation-sender.js

@@ -95,6 +95,7 @@ export function createWorkflowObservationSender({
   let terminal = null;
   let startPromise = null;
   let admittedAtMs = null;
+  let submittedTerminalAt = null;
 
   async function post(path, body, attempts) {
     let response = null;
@@ -191,10 +192,13 @@ export function createWorkflowObservationSender({
     // A very short provider turn can finish before the start RPC commits.
     // For a new run, record when the terminal event is submitted after
     // admission; the event itself remains the real provider event.
-    const observedAt = new Date(Math.max(now().getTime(), admittedAtMs + 1)).toISOString();
+    // The intake's immutable replay identity includes observed_at. Freeze it
+    // before the first send so another flush after a lost response (including
+    // concurrent flushes) resubmits the exact same event.
+    submittedTerminalAt ??= new Date(Math.max(now().getTime(), admittedAtMs + 1)).toISOString();
     return sendTypedTerminal({
       idempotencyKey: terminalIdempotencyKey(normalizedIntent, normalizedBinding),
-      observedAt,
+      observedAt: submittedTerminalAt,
     });
   }