@awak-app/simy-cli 0.5.34 → 0.5.36

package/src/local-task.js

@@ -19,6 +19,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 
 import { resolveDesktopExecutorCommand } from "./desktop-executor.js";
+import { providerBudgetTokens } from "./orchestrator/budget.js";
 import {
   buildLocalTaskArtifactRefs,
   MAX_LOCAL_TASK_ARTIFACT_REFS,
@@ -41,9 +42,13 @@ import { signalExecutorProcess } from "./runner.js";
 import {
   createWorkflowObservationSender,
   normalizeWorkflowObservationBinding,
+  normalizeWorkflowStartIntent,
 } from "./workflow-observation-sender.js";
+import { uploadWorkflowDeliverables } from "./workflow-deliverable-upload.js";
 
-export const DEFAULT_LOCAL_TASK_TOKEN_BUDGET = 100_000;
+// Weighted tokens (cache reads count at 1/10). A real Claude Code WorkFlow step with the
+// Purpose Charter context measured ~200k weighted tokens on dev, so 100k failed every run.
+export const DEFAULT_LOCAL_TASK_TOKEN_BUDGET = 500_000;
 export const DEFAULT_LOCAL_TASK_TIMEOUT_MS = 10 * 60_000;
 export const MAX_LOCAL_TASK_TOKEN_BUDGET = 10_000_000;
 export const MAX_LOCAL_TASK_TIMEOUT_MS = 60 * 60_000;
@@ -256,6 +261,7 @@ export function createLocalTask({
   idempotencyKeyHash = null,
   requestFingerprint = null,
   workflowObservationBinding = null,
+  workflowStartIntent = null,
 }) {
   validateTaskId(id);
   const now = new Date().toISOString();
@@ -268,6 +274,13 @@ export function createLocalTask({
     workflowObservationBinding,
     { provider: backend },
   );
+  const normalizedWorkflowStartIntent = normalizeWorkflowStartIntent(
+    workflowStartIntent,
+    { provider: backend },
+  );
+  if (normalizedWorkflowObservationBinding && normalizedWorkflowStartIntent) {
+    throw new Error("WorkFlow binding and start intent are mutually exclusive.");
+  }
   return {
     id,
     kind: "local_task",
@@ -316,6 +329,17 @@ export function createLocalTask({
           },
         }
       : {}),
+    ...(normalizedWorkflowStartIntent
+      ? {
+          workflow_start_intent: normalizedWorkflowStartIntent,
+          workflow_observation: {
+            status: "pending",
+            workflow_id: normalizedWorkflowStartIntent.workflow_id,
+            workflow_run_id: null,
+            development_outcome: "unverified",
+          },
+        }
+      : {}),
     timeout_ms: normalizedTimeout,
     created_at: now,
     updated_at: now,
@@ -348,6 +372,7 @@ export function createLocalTaskRequestFingerprint({
   attachmentManifest,
   scenarioPack,
   workflowObservationBinding = null,
+  workflowStartIntent = null,
 }) {
   const normalizedModel = normalizeLocalTaskModel(model);
   const manifest = Array.isArray(attachmentManifest)
@@ -364,6 +389,13 @@ export function createLocalTaskRequestFingerprint({
     workflowObservationBinding,
     { provider: backend },
   );
+  const normalizedWorkflowStartIntent = normalizeWorkflowStartIntent(
+    workflowStartIntent,
+    { provider: backend },
+  );
+  if (normalizedWorkflowObservationBinding && normalizedWorkflowStartIntent) {
+    throw new Error("WorkFlow binding and start intent are mutually exclusive.");
+  }
   const payload = {
     instruction: String(instruction || "").trim(),
     backend: String(backend || ""),
@@ -380,6 +412,9 @@ export function createLocalTaskRequestFingerprint({
     ...(normalizedWorkflowObservationBinding
       ? { workflow_observation_binding: normalizedWorkflowObservationBinding }
       : {}),
+    ...(normalizedWorkflowStartIntent
+      ? { workflow_start_intent: normalizedWorkflowStartIntent }
+      : {}),
   };
   return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
 }
@@ -394,6 +429,7 @@ export async function startLocalTask(
     session = null,
     apiOrigin = null,
     observationFetch = globalThis.fetch,
+    deliverableUploadSleep = undefined,
   } = {},
 ) {
   if (!task || task.status !== "queued") throw new Error("Local Task must be queued.");
@@ -475,6 +511,7 @@ export async function startLocalTask(
 
   const observationSender = createWorkflowObservationSender({
     binding: task.workflow_observation_binding,
+    startIntent: task.workflow_start_intent,
     backend: task.backend,
     session,
     apiOrigin,
@@ -601,7 +638,22 @@ export async function startLocalTask(
         0,
       );
       if (observationSender) {
-        task.workflow_observation = await observationSender.flush();
+        // flush() is designed not to reject; guard anyway so a sender failure
+        // can never leave the Local Task unfinished.
+        try {
+          task.workflow_observation = await observationSender.flush();
+        } catch {
+          task.workflow_observation = {
+            status: "failed",
+            workflow_id:
+              task.workflow_observation_binding?.workflow_id ||
+              task.workflow_start_intent?.workflow_id ||
+              null,
+            workflow_run_id: task.workflow_observation_binding?.workflow_run_id || null,
+            development_outcome: "unverified",
+            reason_code: "observation_sender_error",
+          };
+        }
       }
 
       let artifacts = [];
@@ -662,6 +714,40 @@ export async function startLocalTask(
           : [],
       };
       task.warnings = task.result.warnings;
+      // G3: deliverables are uploaded only after the typed terminal was
+      // accepted for a succeeded Provider turn, because Backend authorizes a
+      // device claim only against that consumed receipt. The terminal itself
+      // was already sent above, so an upload failure never withholds it; the
+      // failure is recorded next to the observation instead.
+      const typedReceipt =
+        task.workflow_observation?.status === "accepted" &&
+        typeof task.workflow_observation.receipt_outcome === "string";
+      if (
+        observationSender &&
+        typedReceipt &&
+        task.status === "succeeded" &&
+        observationSender.terminalOutcome() === "succeeded" &&
+        artifacts.length > 0
+      ) {
+        task.workflow_observation = {
+          ...task.workflow_observation,
+          deliverable_upload: await uploadWorkflowDeliverables({
+            binding: observationSender.binding(),
+            observationId: task.workflow_observation.observation_id,
+            localTaskId: task.id,
+            artifacts,
+            readArtifactBytes: async (artifactId) => {
+              const verified = await localTaskArtifact(task, artifactId);
+              return verified ? readFile(verified.local_path) : null;
+            },
+            session,
+            apiOrigin,
+            fetchImpl: observationFetch,
+            environment,
+            ...(deliverableUploadSleep ? { sleep: deliverableUploadSleep } : {}),
+          }),
+        };
+      }
       task.completed_at = new Date().toISOString();
       task.updated_at = task.completed_at;
       emitTaskEvent(task, "status", {
@@ -771,6 +857,7 @@ export function localTaskSnapshot(task, { includeEvents = true, includeLocalPath
           idempotency_key_hash: task.idempotency_key_hash || null,
           request_fingerprint: task.request_fingerprint || null,
           workflow_observation_binding: task.workflow_observation_binding || null,
+          workflow_start_intent: task.workflow_start_intent || null,
         }
       : {}),
   };
@@ -964,6 +1051,10 @@ function restoreLocalTask(snapshot) {
     snapshot.workflow_observation_binding,
     { provider: snapshot.backend },
   );
+  const workflowStartIntent = normalizeWorkflowStartIntent(
+    snapshot.workflow_start_intent,
+    { provider: snapshot.backend },
+  );
   return {
     ...snapshot,
     outputs_root_expected:
@@ -978,6 +1069,7 @@ function restoreLocalTask(snapshot) {
     warnings: Array.isArray(snapshot.warnings) ? snapshot.warnings : [],
     token_usage: snapshot.token_usage || { records: [] },
     workflow_observation_binding: workflowObservationBinding,
+    workflow_start_intent: workflowStartIntent,
     workflow_observation: snapshot.workflow_observation || null,
     child: null,
     operation_promise: null,
@@ -1180,7 +1272,8 @@ function validateIdempotencyKey(value) {
 }
 
 function providerTokenCount(record) {
-  return Number(record?.total_tokens || 0);
+  // Budget-weighted (cache reads at 1/10); raw totals stay in token_usage.
+  return providerBudgetTokens(record);
 }
 
 function allowCodexRuntimeTemp(command, runtimeTempRoot) {

package/src/orchestrator/budget.js

@@ -111,9 +111,33 @@ export function canStartProvider(snapshot, { attemptNumber, phase }) {
 export function tokenUsageTotal(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return 0;
   if (Array.isArray(value.records)) {
-    return value.records.reduce((sum, record) => sum + recordTokenTotal(record), 0);
+    return value.records.reduce((sum, record) => sum + providerBudgetTokens(record), 0);
   }
-  return recordTokenTotal(value);
+  return providerBudgetTokens(value);
+}
+
+// Cache reads are billed at roughly a tenth of fresh input, and Claude Code
+// re-reads its whole cached context every turn (~300k per short run). Counting
+// them in full made every Claude Local Task exhaust a 100k budget, so the
+// budget counts input + output + cache creation + ceil(cache_read / 10).
+// token_usage records keep the raw totals (including cache reads) unchanged.
+export const CACHE_READ_BUDGET_DIVISOR = 10;
+
+export function providerBudgetTokens(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return 0;
+  const cacheRead = nonNegativeNumber(value.cached_input_tokens);
+  if (cacheRead === null) return recordTokenTotal(value);
+  const output = nonNegativeNumber(value.tokens_out ?? value.output_tokens) ?? 0;
+  const weightedCacheRead = Math.ceil(cacheRead / CACHE_READ_BUDGET_DIVISOR);
+  const uncached = nonNegativeNumber(value.uncached_input_tokens);
+  if (uncached !== null) {
+    // Claude: input_tokens excludes cache reads and cache creation.
+    const cacheCreation = nonNegativeNumber(value.cache_creation_input_tokens) ?? 0;
+    return uncached + cacheCreation + output + weightedCacheRead;
+  }
+  // Codex: input_tokens already includes cached_input_tokens.
+  const input = nonNegativeNumber(value.tokens_in ?? value.input_tokens) ?? 0;
+  return Math.max(input - cacheRead, 0) + output + weightedCacheRead;
 }
 
 function recordTokenTotal(value) {

package/src/runner.js

@@ -48,6 +48,7 @@ import { createSqmChecker } from "./sqm/index.js";
 import {
   createWorkflowObservationSender,
   normalizeWorkflowObservationBinding,
+  normalizeWorkflowStartIntent,
 } from "./workflow-observation-sender.js";
 import { saveCodingRunSnapshot } from "./coding-run-store.js";
 
@@ -96,7 +97,14 @@ export function createRun({ runId, request, session, apiOrigin, localStateRoot =
       request?.workflow_observation_binding,
       { provider: request?.backend },
     ),
+    workflow_start_intent: normalizeWorkflowStartIntent(
+      request?.workflow_start_intent,
+      { provider: request?.backend },
+    ),
   };
+  if (normalizedRequest.workflow_observation_binding && normalizedRequest.workflow_start_intent) {
+    throw new Error("WorkFlow binding and start intent are mutually exclusive.");
+  }
   return {
     id: runId,
     request: normalizedRequest,
@@ -136,6 +144,17 @@ export function createRun({ runId, request, session, apiOrigin, localStateRoot =
               },
             }
           : {}),
+        ...(normalizedRequest.workflow_start_intent
+          ? {
+              workflow_observation: {
+                status: "pending",
+                workflow_id: normalizedRequest.workflow_start_intent.workflow_id,
+                workflow_run_id: null,
+                development_outcome: "unverified",
+                start_intent: normalizedRequest.workflow_start_intent,
+              },
+            }
+          : {}),
       },
     }),
   };
@@ -181,6 +200,8 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null, loc
       proposal_id: typeof charter.proposal_id === "string" ? charter.proposal_id : null,
       workflow_observation_binding:
         snapshot.metadata?.workflow_observation?.binding ?? null,
+      workflow_start_intent:
+        snapshot.metadata?.workflow_observation?.start_intent ?? null,
       charter_context: {
         source_charter_id: charter.id,
         audit_backend: charter.audit_backend,
@@ -798,9 +819,11 @@ export async function executeProcessAttempt({
   const tokenUsageRecords = [];
   const phase = marker === "SIMY_AUDIT_JSON:" ? "reviewer" : "executor";
   const observationSender =
-    phase === "executor" && run.snapshot.metadata?.workflow_observation?.status !== "accepted"
+    phase === "executor" &&
+    !["accepted", "already_recorded"].includes(run.snapshot.metadata?.workflow_observation?.status)
       ? createWorkflowObservationSender({
           binding: run.request.workflow_observation_binding,
+          startIntent: run.request.workflow_start_intent,
           backend,
           session: run.session,
           apiOrigin: run.apiOrigin,
@@ -855,16 +878,28 @@ export async function executeProcessAttempt({
       stdoutDecoder.flush();
       stderrDecoder.flush();
       run.child = null;
+      // The run must always resolve: a WorkFlow observation failure (or a
+      // sender bug) never changes or blocks the Provider result. flush() is
+      // bounded by per-request timeouts and is designed not to reject.
       if (observationSender) {
-        const observation = await observationSender.flush();
-        run.snapshot.metadata.workflow_observation = {
-          ...observation,
-          binding: run.request.workflow_observation_binding,
-        };
-        if (observation.status === "failed") {
+        try {
+          const observation = await observationSender.flush();
+          run.snapshot.metadata.workflow_observation = {
+            ...observation,
+            binding: run.request.workflow_observation_binding,
+            start_intent: run.request.workflow_start_intent,
+          };
+          if (observation.status === "failed") {
+            emitOutput(
+              run,
+              "WorkFlow observation was not accepted; the Provider result is unchanged and development completion remains unverified.",
+              { backend },
+            );
+          }
+        } catch {
           emitOutput(
             run,
-            "WorkFlow observation was not accepted; the Provider result is unchanged and development completion remains unverified.",
+            "WorkFlow observation could not be sent; the Provider result is unchanged and development completion remains unverified.",
             { backend },
           );
         }

package/src/session-supervision/claude-sessions.js

@@ -0,0 +1,131 @@
+import { constants } from 'node:fs';
+import { lstat, open, readdir, realpath } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const MAX_PROJECTS = 256;
+const MAX_TRANSCRIPTS = 4096;
+const MAX_PREFIX_BYTES = 256 * 1024;
+const MAX_LINES = 256;
+const MAX_FILE_BYTES = 64 * 1024 * 1024;
+
+function within(parent, child) {
+  const path = relative(parent, child);
+  return path === '' || (path !== '..' && !path.startsWith(`..${sep}`) && !isAbsolute(path));
+}
+
+async function directory(path) {
+  try {
+    const info = await lstat(path);
+    return info.isDirectory() && !info.isSymbolicLink();
+  } catch { return false; }
+}
+
+async function projectsRoot(home) {
+  if (typeof home !== 'string' || !isAbsolute(home)) return null;
+  const root = join(resolve(home), '.claude', 'projects');
+  if (!await directory(home) || !await directory(join(home, '.claude')) || !await directory(root)) return null;
+  return realpath(root);
+}
+
+function metadataFromPrefix(bytes, id) {
+  // Claude's JSONL is a full transcript. Inspect only a bounded prefix for
+  // envelope fields; never read message bodies into the returned candidate.
+  const text = bytes.toString('utf8');
+  const complete = text.slice(0, text.lastIndexOf('\n') + 1);
+  if (!complete) return null;
+  let cwd = '', title = '', found = false;
+  for (const line of complete.split('\n').slice(0, MAX_LINES)) {
+    if (!line) continue;
+    let item;
+    try { item = JSON.parse(line); } catch { return null; }
+    if (item.sessionId !== id) return null;
+    if (item.type !== 'user' && item.type !== 'assistant') continue;
+    if (item.isSidechain === true) return null;
+    if (typeof item.cwd !== 'string' || !isAbsolute(item.cwd)) continue;
+    if (!cwd) cwd = resolve(item.cwd);
+    if (cwd !== resolve(item.cwd)) return null;
+    if (!title && typeof item.slug === 'string') title = item.slug.replace(/[\x00-\x1f\x7f]/g, '').slice(0, 120);
+    found = true;
+  }
+  return found ? { cwd, title } : null;
+}
+
+async function inspectTranscript(root, projectName, fileName, observedAt) {
+  const id = fileName.slice(0, -'.jsonl'.length);
+  if (!UUID.test(id)) return null;
+  const project = join(root, projectName);
+  if (!await directory(project)) return null;
+  const path = join(project, fileName);
+  let handle;
+  try {
+    const before = await lstat(path);
+    if (!before.isFile() || before.isSymbolicLink() || before.size > MAX_FILE_BYTES) return null;
+    if (!within(root, await realpath(path))) return null;
+    handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+    const opened = await handle.stat();
+    if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino) return null;
+    // Recheck the resolved path and inode after opening, so a swapped project
+    // directory cannot turn a prior path check into a read outside the index.
+    if (!within(root, await realpath(path))) return null;
+    const current = await lstat(path);
+    if (!current.isFile() || current.isSymbolicLink() || current.dev !== opened.dev || current.ino !== opened.ino) return null;
+    const buffer = Buffer.allocUnsafe(Math.min(opened.size, MAX_PREFIX_BYTES));
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const metadata = metadataFromPrefix(buffer.subarray(0, bytesRead), id);
+    if (!metadata) return null;
+    return {
+      provider: 'claude', session: id, cwd: metadata.cwd, title: metadata.title,
+      source: 'claude_cli', lastActivityAt: opened.mtimeMs,
+      observation: { source: 'claude_local_index', observedAt },
+      availability: 'unsupported', model: null,
+      capabilities: { canMonitor: true, canEnroll: false, canAutoContinue: false },
+      reason: 'Claude session ownership and safe exact-session takeover are unverified; monitoring only.',
+    };
+  } catch { return null; }
+  finally { await handle?.close(); }
+}
+
+async function collect({ home = homedir(), limit = 100, session = null } = {}) {
+  const root = await projectsRoot(home);
+  if (!root) return [];
+  const maximum = Number.isInteger(limit) ? Math.max(1, Math.min(limit, 200)) : 100;
+  const observedAt = Date.now();
+  const result = new Map();
+  let inspected = 0;
+  let projects;
+  try { projects = await readdir(root, { withFileTypes: true }); } catch { return []; }
+  for (const entry of projects.filter(item => item.isDirectory() && !item.isSymbolicLink()).slice(0, MAX_PROJECTS)) {
+    const project = join(root, entry.name);
+    let files;
+    try { files = await readdir(project, { withFileTypes: true }); } catch { continue; }
+    for (const file of files) {
+      if (inspected >= MAX_TRANSCRIPTS) break;
+      if (!file.isFile() || file.isSymbolicLink() || !UUID.test(file.name.replace(/\.jsonl$/, '')) || !file.name.endsWith('.jsonl')) continue;
+      const id = file.name.slice(0, -'.jsonl'.length);
+      if (session && id !== session) continue;
+      inspected++;
+      const candidate = await inspectTranscript(root, entry.name, file.name, observedAt);
+      if (!candidate) continue;
+      const key = `${candidate.session}\0${candidate.cwd}`;
+      if (!result.has(key) || candidate.lastActivityAt > result.get(key).lastActivityAt) result.set(key, candidate);
+    }
+    if (inspected >= MAX_TRANSCRIPTS) break;
+  }
+  const sorted = [...result.values()].sort((a, b) => b.lastActivityAt - a.lastActivityAt || a.session.localeCompare(b.session));
+  return session ? sorted : sorted.slice(0, maximum);
+}
+
+export async function listClaudeSessions({ home, limit } = {}) {
+  return collect({ home, limit });
+}
+
+export async function readClaudeSession(session, { home } = {}) {
+  const id = typeof session === 'string' ? session : session?.session;
+  if (typeof id !== 'string' || !UUID.test(id)) return null;
+  const matches = await collect({ home, limit: 200, session: id });
+  const selected = typeof session === 'object' && typeof session.cwd === 'string'
+    ? matches.filter(item => item.cwd === session.cwd) : matches;
+  return selected.length === 1 ? selected[0] : null;
+}