totemlayer 0.1.15 → 0.1.17

package/bin/mission-infrastructure.mjs

@@ -10,7 +10,6 @@ import {
   readPrivateRuntimeJson,
 } from "./mission-agent-session.mjs";
 import { inspectLocalRepository } from "./repository.mjs";
-import { customerInspector } from "./local-inspector.mjs";
 
 const execute = promisify(execFile);
 const sha = (value) => createHash("sha256").update(value).digest("hex");
@@ -252,13 +251,10 @@ export async function runInfrastructureWorkerCycle({
   infrastructureProvider,
   signal,
   emit = () => {},
-  inspector,
-  inspectorOptions,
 }) {
   const kind = candidateWorkItem?.metadata?.kind;
   if (!recoveryOnly && !KINDS.has(kind)) return false;
   if (recoveryOnly && !infrastructureProvider) return false;
-  inspector = customerInspector({ inspector, inspectorOptions });
   if (!_session || !infrastructureProvider)
     throw new Error("Infrastructure work requires the connected agent service.");
   assertMissionAgentSession(_session, baseUrl, expectedAgentId);
@@ -305,18 +301,6 @@ export async function runInfrastructureWorkerCycle({
       };
       await persist();
       const mission = await client.missions.get(missionId, { signal: activeSignal });
-      await inspector.assertAllowed(
-        "input",
-        {
-          goal: mission.goal,
-          workItem: item,
-          infrastructure: mission.infrastructure,
-          workItems: mission.workItems,
-          repository: mission.repository,
-        },
-        { signal: activeSignal },
-      );
-      record.originalTask = String(mission.goal ?? "");
       if (mission.infrastructure?.provider !== "local-static")
         throw new Error("Unsupported infrastructure provider.");
       const repository = await inspectLocalRepository({ TOTEM_REPOSITORY_ROOT: repositoryRoot });
@@ -382,11 +366,6 @@ export async function runInfrastructureWorkerCycle({
     emit({ type: "work_started", missionId, workItemId: record.workItemId, stage: record.kind });
     const action = record.kind === "infrastructure_deploy" ? "app.deploy" : "app.verify";
     if (record.state === "infra_source") {
-      await inspector.assertAllowed(
-        "action",
-        { action: "repository.read", resource: record.repositoryResource, source: record.source },
-        { task: record.originalTask, signal: activeSignal },
-      );
       const effect = await client.missions.reserveEffect(
         missionId,
         {
@@ -415,20 +394,6 @@ export async function runInfrastructureWorkerCycle({
         record.source.sourceDirectory,
         activeSignal,
       );
-      for (const file of bundle.files) {
-        const mediaType = MIME[extname(file.path).toLowerCase()];
-        if (
-          mediaType?.startsWith("text/") ||
-          mediaType === "application/json" ||
-          mediaType === "image/svg+xml"
-        )
-          await inspector.inspectFile(
-            file.path,
-            mediaType === "image/svg+xml" ? "application/xml" : mediaType,
-            Buffer.from(file.content, "base64"),
-            { task: record.originalTask, signal: activeSignal },
-          );
-      }
       if (
         record.kind === "infrastructure_verify" &&
         (bundle.bundleSha256 !== record.source.bundleSha256 ||
@@ -472,16 +437,6 @@ export async function runInfrastructureWorkerCycle({
       await persist();
     }
     if (record.state === "infra_reserved") {
-      await inspector.assertAllowed(
-        "action",
-        {
-          action,
-          resource: `totem:mission:${missionId}:app`,
-          parameters: record.parameters,
-          url: record.deploymentUrl,
-        },
-        { task: record.originalTask, signal: activeSignal },
-      );
       const effect = await client.missions.reserveEffect(
         missionId,
         {
@@ -548,10 +503,6 @@ export async function runInfrastructureWorkerCycle({
       await persist();
     }
     const summary = `${action === "app.deploy" ? "Published" : "Verified"} the reviewed static app locally. The preview is available while its deployment agent is connected.`;
-    await inspector.assertAllowed("output", record.receipt, {
-      task: record.originalTask,
-      signal: activeSignal,
-    });
     await client.missions.complete(
       missionId,
       record.workItemId,

package/bin/mission-worker.mjs

@@ -21,7 +21,6 @@ import { setTimeout as sleep } from "node:timers/promises";
 import { inspectLocalRepository } from "./repository.mjs";
 import { localClientEnvironment } from "./platform-client.mjs";
 import { localModelEndpoint } from "./local-model-provider.mjs";
-import { customerInspector } from "./local-inspector.mjs";
 import { externalModelReply, isExternalModelProvider } from "./model-adapter.mjs";
 import { runDockerNodeTests } from "./docker-test-sandbox.mjs";
 import { acquireMissionAgentSession, assertMissionAgentSession } from "./mission-agent-session.mjs";
@@ -753,10 +752,7 @@ export async function runCodexMissionAgent({
   stage,
   agentName,
   agentAddress,
-  inspector = customerInspector(),
-  task,
 }) {
-  await inspector.assertAllowed("input", prompt, { task, signal });
   if (provider !== "ollama-local")
     throw new Error(
       "The legacy Codex adapter requires explicit provider: ollama-local. Use runLocalMissionAgent for native Qwen by default.",
@@ -842,7 +838,6 @@ export async function runCodexMissionAgent({
       });
   }
   if (!final.trim()) throw new Error("The connected agent returned no final result.");
-  await inspector.assertAllowed("output", { text: final, commands }, { task, signal });
   return { text: final.slice(0, 32000), commands: commands.slice(-30) };
 }
 
@@ -909,14 +904,7 @@ export function redactRepositorySource(source) {
   return output;
 }
 
-export async function repositoryEvidence(
-  checkout,
-  stage,
-  checkoutInfo,
-  inspector = customerInspector(),
-  task,
-  signal,
-) {
+export async function repositoryEvidence(checkout, stage, checkoutInfo) {
   if (!["engineering", "review"].includes(stage)) return "";
   const tracked = (await git(checkout, "ls-files"))
     .split("\n")
@@ -947,9 +935,7 @@ export async function repositoryEvidence(
         throw new Error(`The reviewer cannot inspect the complete changed file: ${path}`);
       continue;
     }
-    const original = await readFile(absolute, "utf8");
-    await inspector.assertAllowed("tool-result", { path, source: original }, { task, signal });
-    const source = redactRepositorySource(original);
+    const source = redactRepositorySource(await readFile(absolute, "utf8"));
     const numbered = source
       .split("\n")
       .map((line, index) => `${index + 1}: ${line}`)
@@ -964,10 +950,7 @@ export async function repositoryEvidence(
   return JSON.stringify({ trackedFiles: paths, changedFiles: changed, files });
 }
 
-async function codeRepositoryEvidence(
-  checkout,
-  { repair = false, inspector = customerInspector(), task, signal } = {},
-) {
+async function codeRepositoryEvidence(checkout, { repair = false } = {}) {
   const checkoutPath = await realpath(checkout);
   const changed = repair
     ? [
@@ -1005,7 +988,6 @@ async function codeRepositoryEvidence(
       continue;
     }
     const content = await readFile(absolute, "utf8");
-    await inspector.assertAllowed("tool-result", { path, content }, { task, signal });
     if (
       /-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:sk-[A-Za-z0-9_-]{20,}|gh[pousr]_[A-Za-z0-9_]{20,}|AKIA[0-9A-Z]{16})\b/.test(
         content,
@@ -1587,10 +1569,7 @@ async function runStructuredMissionAgent({
   reasoning = false,
   rejectionEvidenceDirectory,
   adapterSettings = {},
-  inspector = customerInspector(),
-  task,
 }) {
-  await inspector.assertAllowed("input", prompt, { task, signal });
   const regressionFile =
     stage === "code" && !repair ? await selectMissionRegressionTestFile(checkout) : null;
   const properties =
@@ -1651,9 +1630,8 @@ async function runStructuredMissionAgent({
     throw new Error("Specify the installed model for this provider.");
   const evidence =
     stage === "code"
-      ? await codeRepositoryEvidence(checkout, { repair, inspector, task, signal })
-      : await repositoryEvidence(checkout, stage, checkoutInfo, inspector, task, signal);
-  await inspector.assertAllowed("tool-result", evidence, { task, signal });
+      ? await codeRepositoryEvidence(checkout, { repair })
+      : await repositoryEvidence(checkout, stage, checkoutInfo);
   const regressionInstruction = regressionFile
     ? `\n\nWorker-selected regression file: ${JSON.stringify(regressionFile.path)}. Return exactly this one path in testChanges, as a new file. Do not edit, replace, or rename any existing test file in initial generation. The new .test.js file uses ${regressionFile.moduleType === "module" ? "ES modules: import test from 'node:test' and assert from 'node:assert/strict'" : "CommonJS: require('node:test') and require('node:assert/strict'); use an async test with dynamic import() if the source API is an ES module"}. Import the actual source API with paths relative to this file. Node --test discovers this filename. Baseline expectation changes for accepted new fields are reserved for exact-edit repair after actual test failure.`
     : "";
@@ -1662,7 +1640,6 @@ async function runStructuredMissionAgent({
   let correction = "";
   const useReasoning = reasoning === true && ["code", "review"].includes(stage);
   for (let attempt = 0; attempt < (stage === "code" ? 2 : 1); attempt += 1) {
-    await inspector.assertAllowed("input", correction, { task, signal });
     const generationLimit = useReasoning ? 8192 : stage === "code" ? 4096 : 2048;
     const data = await requestModel(endpoint, {
       method: "POST",
@@ -1709,25 +1686,15 @@ async function runStructuredMissionAgent({
       provider !== "ollama-local" ? data?.choices?.[0]?.message?.content : data?.message?.content;
     if (typeof result !== "string" || !result.trim())
       throw new Error("The local model returned no structured result.");
-    await inspector.assertAllowed("output", result, { task, signal: combined });
     if (stage !== "code") return { text: result.slice(0, 32000), commands: [] };
     try {
       return repair
-        ? await inspector.runAction(
-            { checkout, result },
-            (input) => applyModelFileEdits(input.checkout, input.result),
-            { task, signal: combined },
-          )
-        : await inspector.runAction(
-            { checkout, result },
-            (input) =>
-              applyModelFileChanges(input.checkout, input.result, {
-                requireRegressionTests: true,
-                requireSeparateTestChanges: true,
-                newRegressionTestPath: regressionFile.path,
-              }),
-            { task, signal: combined },
-          );
+        ? await applyModelFileEdits(checkout, result)
+        : await applyModelFileChanges(checkout, result, {
+            requireRegressionTests: true,
+            requireSeparateTestChanges: true,
+            newRegressionTestPath: regressionFile.path,
+          });
     } catch (error) {
       if (rejectionEvidenceDirectory) {
         await mkdir(rejectionEvidenceDirectory, {
@@ -2419,7 +2386,6 @@ async function settleCompletedResult(client, missionId, workItemId, path, record
     stage: record.stage,
     result: record.result,
     leaseToken: record.leaseToken,
-    originalTask: record.originalTask,
   });
 }
 
@@ -2431,7 +2397,6 @@ async function recoverReadyCompletions(
   signal,
   emit,
   limit = Infinity,
-  inspector = customerInspector(),
 ) {
   let handled = 0;
   for (const name of await readdir(directory)) {
@@ -2479,7 +2444,6 @@ async function recoverReadyCompletions(
         await reportBlockedCompletion(record);
         continue;
       }
-      await inspector.assertAllowed("output", record.result, { task: record.originalTask, signal });
       if (record.state === "result_settling")
         await settleCompletedResult(client, missionId, workItemId, path, record, signal);
       await client.missions.complete(
@@ -2557,26 +2521,7 @@ export async function runMissionWorker({
   emit = () => {},
   runAgent = runLocalMissionAgent,
   adapterSettings = {},
-  inspector,
-  inspectorOptions,
 }) {
-  inspector = customerInspector({ inspector, inspectorOptions });
-  const uncheckedRunAgent = runAgent;
-  let originalTask;
-  runAgent = async (input) => {
-    const result = await inspector.runAction(
-      {
-        prompt: input.prompt,
-        checkout: input.checkout,
-        write: input.write ?? false,
-        stage: input.stage,
-      },
-      (snapshot) => uncheckedRunAgent({ ...input, ...snapshot, inspector, task: originalTask }),
-      { task: originalTask, signal: input.signal },
-    );
-    await inspector.assertAllowed("output", result, { task: originalTask, signal: input.signal });
-    return result;
-  };
   if (!UUID.test(missionId)) throw new Error("Provide a valid mission ID.");
   missionModelEndpoint(provider, { ollamaUrl, qwenUrl, nimUrl });
   model ??=
@@ -2655,7 +2600,6 @@ export async function runMissionWorker({
           signal,
           emit,
           _singleCycle ? 1 : Infinity,
-          inspector,
         );
         if (_singleCycle && recovered) return { activity: "recovery", handled: recovered };
         const reconciled = await recoverKnownLocalTestFailures(
@@ -2668,7 +2612,6 @@ export async function runMissionWorker({
         );
         if (_singleCycle && reconciled) return { activity: "recovery", handled: reconciled };
         const mission = await client.missions.get(missionId, { signal });
-        originalTask = String(mission.goal ?? "");
         if (
           mission.status === "canceled" ||
           mission.status === "completed" ||
@@ -2713,32 +2656,6 @@ export async function runMissionWorker({
           )
             continue;
           processed += 1;
-          try {
-            await inspector.assertAllowed(
-              "input",
-              {
-                goal: mission.goal,
-                desiredOutput: mission.desiredOutput,
-                repository: mission.repository,
-                workItem,
-                events: mission.events ?? [],
-                artifacts: mission.artifacts ?? [],
-              },
-              { task: originalTask, signal },
-            );
-          } catch (error) {
-            if (!error.code?.startsWith("INSPECTION_")) throw error;
-            if (!reportedAttention.has(workItem.id)) {
-              await recordRecoveryBlocker(workItem, error.code);
-              emit({
-                type: "needs_attention",
-                workItemId: workItem.id,
-                code: error.code,
-                message: "The customer-side inspector blocked this assignment before launch.",
-              });
-            }
-            continue;
-          }
           let stage;
           try {
             stage = stageOf(workItem);
@@ -3091,16 +3008,6 @@ export async function runMissionWorker({
                   ? ["repository.read"]
                   : [];
           const authorizeLocalLaunch = async () => {
-            await inspector.assertAllowed(
-              "action",
-              {
-                stage,
-                actions: repositoryActions,
-                resource: mission.repository?.url ?? null,
-                objective: workItem.objective,
-              },
-              { task: originalTask, signal: combined },
-            );
             // Renewal rechecks mission state, current credential, membership, and the lease.
             await client.missions.renew(missionId, workItem.id, claim.leaseToken, {
               signal: combined,
@@ -3149,15 +3056,6 @@ export async function runMissionWorker({
               for (const repositoryAction of repositoryActions) {
                 if (!mission.repository)
                   throw new Error("This assignment needs a selected repository.");
-                await inspector.assertAllowed(
-                  "action",
-                  {
-                    action: repositoryAction,
-                    resource: mission.repository.url,
-                    objective: workItem.objective,
-                  },
-                  { task: originalTask, signal: combined },
-                );
                 const reservation =
                   (prior?.reservedEffects ?? []).find(
                     (effect) =>
@@ -3199,16 +3097,6 @@ export async function runMissionWorker({
                   effectIds,
                 });
                 for (const effectId of effectIds) {
-                  await inspector.assertAllowed(
-                    "action",
-                    {
-                      effectId,
-                      actions: repositoryActions,
-                      resource: mission.repository.url,
-                      objective: workItem.objective,
-                    },
-                    { task: originalTask, signal: combined },
-                  );
                   const dispatch = await client.missions.dispatchEffect(
                     missionId,
                     effectId,
@@ -3548,7 +3436,6 @@ export async function runMissionWorker({
                   state: "result_settling",
                   stage,
                   result,
-                  originalTask,
                   leaseToken: claim.leaseToken,
                   effectIds: [...effectIds],
                   repositoryUrl: mission.repository.url,
@@ -3569,15 +3456,10 @@ export async function runMissionWorker({
                   state: "ready",
                   stage,
                   result,
-                  originalTask,
                   leaseToken: claim.leaseToken,
                 });
               }
             }
-            await inspector.assertAllowed("output", result, {
-              task: originalTask,
-              signal: combined,
-            });
             await client.missions.complete(
               missionId,
               workItem.id,

package/bin/model-adapter.mjs

@@ -4,6 +4,37 @@ import { tmpdir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import { createCommandAdapter, createHttpAdapter } from "./worker-core/adapters.mjs";
 import { installedClientInvocation, localClientEnvironment } from "./platform-client.mjs";
+import { WorkerError } from "./worker-core/errors.mjs";
+
+export function providerFailureCode(text) {
+  if (
+    /unexpected argument|unknown option|unrecognized option|no such option|unknown flag/i.test(text)
+  )
+    return "AGENT_CLI_INCOMPATIBLE";
+  if (
+    /not logged in|authentication required|invalid[_ ]api[_ ]key|unauthorized|refresh token.*(?:expired|reused)|sign in.*required/i.test(
+      text,
+    )
+  )
+    return "AGENT_AUTH_REQUIRED";
+  if (
+    /usage limit|rate limit|quota.*(?:exceeded|insufficient)|insufficient_quota|credit balance/i.test(
+      text,
+    )
+  )
+    return "AGENT_QUOTA_EXCEEDED";
+  if (
+    /sandbox.*(?:setup failed|not available|not configured|unsupported|error)|CreateProcessAsUser|error 1385/i.test(
+      text,
+    )
+  )
+    return "AGENT_SANDBOX_UNAVAILABLE";
+  if (
+    /model.*(?:not found|not supported|does not exist|not have access)|model_not_found/i.test(text)
+  )
+    return "AGENT_MODEL_UNAVAILABLE";
+  return "AGENT_EXIT_FAILED";
+}
 
 export const EXTERNAL_PROVIDERS = ["codex", "claude", "command", "http"];
 export const isExternalModelProvider = (provider) => EXTERNAL_PROVIDERS.includes(provider);
@@ -88,7 +119,7 @@ export async function externalModelReply({
             continue;
           }
           if (event.type === "turn.failed" || event.type === "error")
-            throw new Error("Codex turn failed.");
+            throw new WorkerError(providerFailureCode(event.error?.message ?? event.message ?? ""));
           if (event.type === "item.completed" && event.item?.type === "agent_message")
             final = event.item.text;
         }
@@ -113,7 +144,8 @@ export async function externalModelReply({
       ];
       parseResult = (output) => {
         const result = JSON.parse(output);
-        if (result.is_error || result.subtype !== "success") throw new Error("Claude turn failed.");
+        if (result.is_error || result.subtype !== "success")
+          throw new WorkerError(providerFailureCode(String(result.result ?? "")));
         return {
           status: "completed",
           output: result.structured_output
@@ -153,6 +185,7 @@ export async function externalModelReply({
         env,
         timeoutMs,
         parseResult,
+        ...(["codex", "claude"].includes(provider) ? { classifyFailure: providerFailureCode } : {}),
       });
     }
     const result = await adapter.run({ prompt, signal, runId: randomUUID() });

package/bin/network-retry.mjs

@@ -0,0 +1,26 @@
+import { pause } from "./network.mjs";
+
+export function transientNetworkError(error) {
+  return (
+    error?.status === 429 ||
+    error?.status >= 500 ||
+    ["NETWORK_BUSY", "NETWORK_ERROR", "TIMEOUT"].includes(error?.code)
+  );
+}
+
+// Only use for reads or mutations protected by a durable idempotency key.
+export async function retryNetwork(
+  operation,
+  { signal, onRetry = () => {}, delayMs = 1000, attempts = 4 } = {},
+) {
+  for (let attempt = 0; ; attempt++) {
+    signal?.throwIfAborted();
+    try {
+      return await operation();
+    } catch (error) {
+      if (signal?.aborted || !transientNetworkError(error) || attempt + 1 >= attempts) throw error;
+      onRetry(error);
+      await pause(Math.min(delayMs * 2 ** attempt, 10000), signal);
+    }
+  }
+}