agent-valley 2.0.0 → 2.2.0

package/dist/supervisor.js

@@ -6618,8 +6618,90 @@ var init_capture_schema = __esm(() => {
   });
 });
 
+// ../../packages/core/src/chief/container-observation-policy.ts
+function containerTargetHealthy(result) {
+  return result.status === "collected" && result.state === "running" && result.ready === true && result.logsAvailable !== false && result.statsAvailable !== false && result.issues.length === 0;
+}
+var targetName, contextName, dnsName, timestamp, digest, containerObservationTargetSchema, containerObservationPolicySchema, containerObservationResultSchema, containerObservationSnapshotSchema;
+var init_container_observation_policy = __esm(() => {
+  init_zod();
+  targetName = string2().regex(/^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/, "Use a container name or ID, without CLI flags.");
+  contextName = string2().regex(/^[A-Za-z0-9][A-Za-z0-9_.:@/-]{0,199}$/, "Use an existing CLI context name.").refine((value) => !value.includes("://"), "Use a context name, not a URL or credentials.");
+  dnsName = string2().regex(/^[a-z0-9](?:[a-z0-9.-]{0,251}[a-z0-9])?$/, "Use an explicit Kubernetes name.");
+  timestamp = string2().datetime({ offset: true });
+  digest = string2().regex(/^[a-f0-9]{64}$/);
+  containerObservationTargetSchema = discriminatedUnion("kind", [
+    strictObject({ id: targetName, kind: literal("docker"), container: targetName, context: contextName.optional() }),
+    strictObject({
+      id: targetName,
+      kind: literal("kubernetes"),
+      namespace: dnsName,
+      pod: dnsName,
+      container: targetName,
+      context: contextName.optional()
+    })
+  ]);
+  containerObservationPolicySchema = strictObject({
+    enabled: boolean2().default(true),
+    targets: array(containerObservationTargetSchema).min(1).max(20),
+    poll_interval_sec: number2().int().min(1).max(3600).default(30),
+    timeout_ms: number2().int().min(100).max(60000).default(1e4),
+    max_output_bytes: number2().int().min(1024).max(1048576).default(65536),
+    log_tail: number2().int().min(1).max(200).default(50),
+    log_since_sec: number2().int().min(1).max(86400).default(300),
+    cpu_percent_threshold: number2().finite().positive().max(1e4).optional(),
+    memory_percent_threshold: number2().finite().positive().max(100).optional()
+  }).superRefine((policy, ctx) => {
+    if (new Set(policy.targets.map((target) => target.id)).size !== policy.targets.length)
+      ctx.addIssue({ code: "custom", path: ["targets"], message: "Container observation target IDs must be unique." });
+  });
+  containerObservationResultSchema = strictObject({
+    targetId: targetName,
+    kind: _enum(["docker", "kubernetes"]),
+    status: _enum(["collected", "unavailable"]),
+    identity: string2().min(1).max(500).optional(),
+    state: _enum(["running", "waiting", "terminated", "unknown"]).optional(),
+    ready: boolean2().optional(),
+    health: string2().max(100).optional(),
+    exitCode: number2().int().optional(),
+    restartCount: number2().int().nonnegative().optional(),
+    oomKilled: boolean2().optional(),
+    cpuPercent: number2().finite().nonnegative().optional(),
+    memoryPercent: number2().finite().nonnegative().optional(),
+    logExcerpt: string2().max(8192).optional(),
+    logsAvailable: boolean2().optional(),
+    statsAvailable: boolean2().optional(),
+    reason: string2().max(1000).optional(),
+    issues: array(_enum([
+      "not-running",
+      "unhealthy",
+      "oom-killed",
+      "restarting",
+      "restart-increase",
+      "log-error",
+      "cpu-high",
+      "memory-high"
+    ])).max(8),
+    fingerprint: digest
+  });
+  containerObservationSnapshotSchema = strictObject({
+    collectedAt: timestamp,
+    nextPollAt: timestamp,
+    fingerprint: digest,
+    results: array(containerObservationResultSchema).max(20)
+  });
+});
+
 // ../../packages/core/src/chief/execution.ts
 import { createHash } from "node:crypto";
+function chiefRecoveryStopped(mission) {
+  const decision = mission.supervision?.decisions.at(-1);
+  if (decision?.action !== "stop")
+    return false;
+  const stoppedAt = Date.parse(decision.at);
+  const intervenedAt = Date.parse(mission.execution?.interventionAt ?? "");
+  return !Number.isFinite(stoppedAt) || !Number.isFinite(intervenedAt) || intervenedAt <= stoppedAt;
+}
 function classifyFailure(reason) {
   if (/unauthori[sz]ed|authentication|login required|log in|expired token|invalid.*(?:token|api.key)|\b401\b|\b403\b/i.test(reason))
     return "authentication";
@@ -6654,21 +6736,21 @@ function assertExecutionBudget(mission, now = Date.now()) {
     return;
   const state = executionState(mission);
   if (now - Date.parse(state.startedAt) >= policy.maxDurationSec * 1000)
-    throw new MissionPause("Mission time limit reached. Increase --duration on resume to continue the original goal.", "budget");
+    throw new MissionPause("Mission time limit reached. The original goal remains unresolved within its saved duration.", "budget");
   if (state.runsStarted >= policy.maxRuns)
-    throw new MissionPause("Mission Actor call limit reached. Increase --runs on resume to continue.", "budget");
+    throw new MissionPause("Mission Actor call limit reached. The original goal remains unresolved within its saved call budget.", "budget");
   if (policy.maxEstimatedCostUsd !== undefined) {
     const finished = mission.operations?.runs.filter((run) => run.finishedAt) ?? [];
     const reconciled = new Map(state.costReconciliations?.map((entry) => [entry.runId, entry.costUsd]));
     if (finished.some((run) => run.costUsd === null && !reconciled.has(run.runId)))
-      throw new MissionPause("Cost headroom is unknown. Inspect billing, then reconcile each unresolved run using --account-run <id> --account-cost <usd> on resume; no zero-cost assumption was made.", "budget");
+      throw new MissionPause("Cost headroom is unknown. Unresolved billing evidence prevents further calls; no zero-cost assumption was made.", "budget");
     if (finished.reduce((sum, run) => sum + (run.costUsd ?? reconciled.get(run.runId) ?? 0), 0) >= policy.maxEstimatedCostUsd)
-      throw new MissionPause("Configured-price estimated cost limit reached. Increase --cost on resume to continue.", "budget");
+      throw new MissionPause("Configured-price estimated cost limit reached. The goal remains unresolved within its saved cost budget.", "budget");
   }
 }
 function assertExecutionDeadline(mission, now = Date.now()) {
   if (mission.executionPolicy && now - Date.parse(executionState(mission).startedAt) >= mission.executionPolicy.maxDurationSec * 1000)
-    throw new MissionPause("Mission time limit reached. Increase --duration on resume to continue the original goal.", "budget");
+    throw new MissionPause("Mission time limit reached. The original goal remains unresolved within its saved duration.", "budget");
 }
 function reconcileRunCost(mission, runId, costUsd) {
   const run = mission.operations?.runs.find((entry) => entry.runId === runId);
@@ -6693,7 +6775,8 @@ function progressKey(mission, fingerprint) {
       value: metric.value,
       timestamp: metric.timestamp
     })),
-    effects: mission.tasks.map((task) => ({ id: task.id, effectState: task.effectState }))
+    effects: mission.tasks.map((task) => ({ id: task.id, effectState: task.effectState })),
+    containers: mission.containerObservation?.fingerprint
   })).digest("hex");
 }
 function pauseForFailure(mission, reason, taskId) {
@@ -6703,16 +6786,22 @@ function pauseForFailure(mission, reason, taskId) {
   const state = mission.tasks.find((entry) => entry.id === taskId);
   if (task?.effectScope === "external" && state?.effectState === "running") {
     state.effectState = "unknown";
-    throw new MissionPause(`External effect for ${taskId} is uncertain. Inspect the destination, then resume with --resolve-effect ${taskId} --effect-result completed|not-applied.`, "unknown-effect");
+    throw new MissionPause(`External effect for ${taskId} is uncertain. Its destination outcome has not been established; it will not be repeated.`, "unknown-effect");
   }
   const kind = classifyFailure(reason);
-  if (kind === "authentication" || kind === "environment")
-    throw new MissionPause(`${reason} Restore the required service or CLI, then use --resume with --retry.`, kind);
+  if (kind === "authentication" || kind === "environment") {
+    if (mission.supervision)
+      return;
+    throw new MissionPause(`${reason} Required source access is unavailable; the goal remains unresolved.`, kind);
+  }
   if (kind !== "rate-limit" && kind !== "provider")
     return;
   const execution = executionState(mission);
-  if (execution.retries >= mission.executionPolicy.maxRetries)
-    throw new MissionPause(`${reason} Automatic retries exhausted. Repair the provider and resume with --retry.`, kind);
+  if (execution.retries >= mission.executionPolicy.maxRetries) {
+    if (mission.supervision)
+      return;
+    throw new MissionPause(`${reason} Automatic retries exhausted; the goal remains unresolved.`, kind);
+  }
   execution.retries += 1;
   const delay = Math.min(300000, mission.executionPolicy.retryDelayMs * 2 ** (execution.retries - 1));
   throw new MissionPause(reason, kind, new Date(Date.now() + delay).toISOString());
@@ -6770,7 +6859,10 @@ var init_execution = __esm(() => {
       "implementation",
       "unknown-effect",
       "budget",
-      "interrupted"
+      "interrupted",
+      "chief-wait",
+      "chief-unavailable",
+      "integrity"
     ]).optional(),
     progressKey: string2().optional(),
     interventionAt: exports_iso.datetime().optional(),
@@ -7168,6 +7260,7 @@ var price, chiefConfigSchema;
 var init_chief_schema = __esm(() => {
   init_zod();
   init_capture_schema();
+  init_container_observation_policy();
   init_execution();
   init_metric_source_policy();
   init_operations();
@@ -7176,6 +7269,7 @@ var init_chief_schema = __esm(() => {
   init_tool_environment();
   price = number2().finite().nonnegative().optional();
   chiefConfigSchema = strictObject({
+    container_observation: containerObservationPolicySchema.optional(),
     tool_env_keys: toolEnvKeysSchema.optional(),
     execution: strictObject({
       max_parallel: number2().int().min(1).max(8).default(3),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-valley",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "type": "module",
   "engines": {
     "node": ">=26.10.0",