@namzu/cli 35.0.0 → 36.1.0

package/dist/chunks/resident-7D6IM5LP.js

@@ -0,0 +1,1314 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  decideHeadlessTrust
+} from "./chunk-C5WBEO3X.js";
+import {
+  ConfigLoadError,
+  ConfigValueError
+} from "./chunk-RC6X3ZY6.js";
+import "./chunk-KONYGNG6.js";
+import {
+  Command
+} from "./chunk-MZP6SH3M.js";
+import "./chunk-KU3W6IHV.js";
+import {
+  resolveTrustedProjectContext
+} from "./chunk-CHIEVVQ2.js";
+import "./chunk-K76WV7TN.js";
+import "./chunk-US5ZFPAU.js";
+import "./chunk-6LLJQ3KY.js";
+import {
+  EXIT_BAD_CONFIG,
+  EXIT_UNTRUSTED,
+  EXIT_USAGE
+} from "./chunk-Y7B67G22.js";
+import {
+  createResident,
+  finishRunner,
+  lookupResident,
+  publicRunner,
+  queryRunner,
+  readRunner,
+  readRunnerInstance,
+  releaseRunner,
+  reserveRunner,
+  residentDirectoryFor,
+  runOwnedResident
+} from "./chunk-V7TQR6AR.js";
+import {
+  isResidentUuid,
+  loadResidentVerification,
+  readResidentAttemptReceipt
+} from "./chunk-UOOQPODR.js";
+import {
+  SESSION_LOG_READ_BYTES,
+  readSessionStart,
+  readTurnSettlement
+} from "./chunk-O7DBCVNY.js";
+import {
+  parseExecFlags,
+  resolveWorkingDirectory
+} from "./chunk-HFJHHCTY.js";
+import "./chunk-XEUQN4JC.js";
+import {
+  isPermissionMode
+} from "./chunk-5GRV6P5C.js";
+import "./chunk-LXB3S4IC.js";
+import {
+  openSessions
+} from "./chunk-TIGWWAJI.js";
+import "./chunk-H6B6AROX.js";
+import {
+  ensurePrivateStateDirectory
+} from "./chunk-A5UXODFL.js";
+import "./chunk-OLPOM3DR.js";
+import "./chunk-CG65NUSJ.js";
+import "./chunk-JORONMD3.js";
+import "./chunk-Q24K7536.js";
+import "./chunk-NQY5P2EB.js";
+import {
+  ResidentConflictError,
+  SessionPaths,
+  SqliteResidentLearningStore,
+  inspectResidentConsumption,
+  isEntityId,
+  runStoredResidentLearningCycle,
+  runStoredResidentLearningFromObservations
+} from "./chunk-EWKJGHRO.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/commands/resident.ts
+import { stripVTControlCharacters as stripVTControlCharacters3 } from "node:util";
+
+// src/integrations/resident/inspection.ts
+import { join } from "node:path";
+import { isDeepStrictEqual, stripVTControlCharacters } from "node:util";
+function object(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Invalid resident receipt object.");
+  return value;
+}
+__name(object, "object");
+function count(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+    throw new Error("Invalid receipt count.");
+  return value;
+}
+__name(count, "count");
+function text(value) {
+  if (typeof value !== "string") throw new Error("Invalid receipt text.");
+  return value;
+}
+__name(text, "text");
+function id(value) {
+  if (!isResidentUuid(value)) throw new Error("Invalid receipt identity.");
+  return value;
+}
+__name(id, "id");
+function turnId(value) {
+  if (!isEntityId(value, "turn")) throw new Error("Invalid receipt identity.");
+  return value;
+}
+__name(turnId, "turnId");
+function identity(value) {
+  const v = object(value);
+  if (v.version !== 1) throw new Error("Unknown attempt receipt version.");
+  if (!isEntityId(v.sessionId, "session")) throw new Error("Invalid receipt identity.");
+  return {
+    version: 1,
+    pursuitId: id(v.pursuitId),
+    claimId: id(v.claimId),
+    sessionId: v.sessionId,
+    turnId: turnId(v.turnId)
+  };
+}
+__name(identity, "identity");
+function parseBudget(value) {
+  if (value === void 0) return null;
+  const b = object(value);
+  if (typeof b.poisoned !== "boolean") throw new Error("Invalid budget state.");
+  return {
+    ownTokens: count(b.ownTokens),
+    treeTokens: count(b.treeTokens),
+    inFlightRequests: count(b.inFlightRequests),
+    unsettledChildren: count(b.unsettledChildren),
+    poisoned: b.poisoned,
+    unresolvedRequests: b.unresolvedRequests === void 0 ? null : count(b.unresolvedRequests)
+  };
+}
+__name(parseBudget, "parseBudget");
+function parseFinish(value) {
+  const f = object(value);
+  if (f.cleanup !== "confirmed" && f.cleanup !== "unconfirmed")
+    throw new Error("Unknown cleanup state.");
+  if (f.error !== null) text(f.error);
+  if (f.stopReason !== null) text(f.stopReason);
+  const decision = f.decision === null ? null : object(f.decision);
+  if (decision && !["wait", "complete", "blocked"].includes(text(decision.kind)))
+    throw new Error("Invalid attempt outcome.");
+  const u = f.usage === null ? null : object(f.usage);
+  const cost = u ? object(u.cost) : null;
+  if (cost && (typeof cost.totalCost !== "number" || !Number.isFinite(cost.totalCost) || cost.totalCost < 0))
+    throw new Error("Invalid cost.");
+  return {
+    ...identity(f),
+    finishedAt: count(f.finishedAt),
+    cleanup: f.cleanup,
+    error: f.error,
+    decision,
+    budget: parseBudget(f.budget),
+    verificationPolicy: f.verificationPolicy,
+    verification: f.verification ? object(f.verification) : null,
+    usage: u && cost ? {
+      totalTokens: count(u.totalTokens),
+      cost: {
+        totalCost: cost.totalCost,
+        unpricedTokens: count(cost.unpricedTokens)
+      }
+    } : null
+  };
+}
+__name(parseFinish, "parseFinish");
+function residentConsumptionResolver(resident) {
+  const read = /* @__PURE__ */ __name(async (path, signal) => {
+    try {
+      return await readResidentAttemptReceipt(resident.root, path, signal);
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+  }, "read");
+  return {
+    maxReadBytes: 2 * 65536 + SESSION_LOG_READ_BYTES,
+    async resolve(admission, signal) {
+      id(admission.claimId);
+      const dir = join(resident.artifactsRoot, admission.claimId);
+      const rawStart = await read(join(dir, "start.json"), signal);
+      if (!rawStart) return null;
+      const start = { ...identity(rawStart), startedAt: count(object(rawStart).startedAt) };
+      if (start.claimId !== admission.claimId || start.pursuitId !== admission.pursuitId)
+        throw new Error("Attempt does not match the admitted claim.");
+      const logPath = new SessionPaths({ home: resident.root, slug: resident.slug }).sessionLog({
+        sessionId: start.sessionId
+      });
+      const opened = await readSessionStart(resident.root, logPath, signal);
+      if (!opened) return null;
+      if (opened.sessionId !== start.sessionId || opened.projectId !== resident.projectId || opened.tenantId !== void 0 && opened.tenantId !== resident.tenantId)
+        throw new Error("Attempt session is outside this resident project.");
+      const settled = await readTurnSettlement(resident.root, logPath, start.turnId, signal);
+      if (settled && settled.sessionId !== start.sessionId)
+        throw new Error("Attempt turn is outside this resident project.");
+      const turn = settled ? {
+        tokenUsage: { totalTokens: count(settled.settlement.usage.totalTokens) },
+        budget: parseBudget(settled.budget)
+      } : null;
+      const rawFinish = await read(join(dir, "finish.json"), signal);
+      const finish = rawFinish === null ? null : parseFinish(rawFinish);
+      if (finish && (!isDeepStrictEqual(identity(start), identity(finish)) || finish.finishedAt < start.startedAt))
+        throw new Error("Attempt receipts disagree.");
+      if (turn && finish?.usage && finish.usage.totalTokens !== turn.tokenUsage.totalTokens)
+        throw new Error("Finish usage disagrees with the settled turn.");
+      const tree = finish?.budget ?? turn?.budget ?? null;
+      const ownTokens = turn?.tokenUsage.totalTokens ?? finish?.usage?.totalTokens ?? null;
+      if (tree && ownTokens !== null && tree.ownTokens !== ownTokens)
+        throw new Error("Tree ledger disagrees with own usage.");
+      let verification = !finish || finish.verificationPolicy ? "unconfirmed" : "unconfigured";
+      if (finish?.verification) {
+        const receipt = object(finish.verification.receipt);
+        if (!/^[a-f0-9]{64}$/.test(text(finish.verification.answerSha256)) || !Array.isArray(receipt.observations) || receipt.observations.length < 1 || receipt.observations.length > 32)
+          throw new Error("Invalid verification receipt.");
+        const expectedScope = {
+          tenantId: resident.tenantId,
+          projectId: resident.projectId,
+          pursuitId: admission.pursuitId,
+          claimId: admission.claimId,
+          sessionId: start.sessionId,
+          turnId: start.turnId,
+          revision: admission.pursuitRevision
+        };
+        if (!isDeepStrictEqual(JSON.parse(text(receipt.scope)), expectedScope) || receipt.turnId !== start.turnId || finish.decision?.kind !== "complete" || finish.error !== null || finish.cleanup !== "confirmed" || receipt.observations.some((item) => {
+          const o = object(item);
+          const at = count(o.observedAt);
+          count(o.bytes);
+          text(o.source);
+          return !/^[a-f0-9]{64}$/.test(text(o.sha256)) || at < start.startedAt || at > finish.finishedAt;
+        }))
+          throw new Error("Verification receipt does not match this attempt.");
+        const policy = object(finish.verificationPolicy);
+        const claims = object(receipt.claims);
+        if (policy.version !== 1 || !Array.isArray(policy.claims) || policy.claims.length < 1 || policy.claims.length > 32 || Object.keys(claims).length !== policy.claims.length)
+          throw new Error("Invalid verification policy.");
+        const requirements = policy.claims.map(object);
+        const sources = new Set(requirements.map((r) => text(r.source)));
+        if (new Set(requirements.map((r) => text(r.id))).size !== requirements.length || requirements.some((r) => {
+          const key = text(r.id);
+          const value = claims[key];
+          return !Object.hasOwn(claims, key) || !(value === null || typeof value === "boolean" || typeof value === "string" && value.length <= 2e3 || typeof value === "number" && Number.isSafeInteger(value)) || Object.hasOwn(r, "expected") && !isDeepStrictEqual(value, r.expected);
+        }) || receipt.observations.length !== sources.size || new Set(receipt.observations.map((o) => text(object(o).source))).size !== sources.size || receipt.observations.some((o) => !sources.has(text(object(o).source))))
+          throw new Error("Incomplete verification evidence.");
+        verification = "recorded";
+      }
+      return {
+        sessionId: start.sessionId,
+        turnId: start.turnId,
+        ownTokens: finish?.usage?.totalTokens ?? ownTokens,
+        treeTokens: tree?.treeTokens ?? null,
+        ownCostUsd: finish?.usage?.cost.totalCost ?? null,
+        unpricedOwnTokens: finish?.usage?.cost.unpricedTokens ?? null,
+        usageFinal: !!turn && !!finish?.usage && finish.error === null && finish.cleanup === "confirmed" && !!tree && tree.inFlightRequests === 0 && tree.unsettledChildren === 0 && !tree.poisoned && tree.unresolvedRequests === 0,
+        cleanup: finish?.cleanup ?? "unknown",
+        verification
+      };
+    }
+  };
+}
+__name(residentConsumptionResolver, "residentConsumptionResolver");
+var line = /* @__PURE__ */ __name((value) => stripVTControlCharacters(value).replace(/[\p{Cc}\p{Cf}]/gu, " "), "line");
+function residentInspectionText(report) {
+  const { recorded, unknown } = report;
+  const deferred = report.attempts.filter((a) => a.receiptStatus === "deferred");
+  const missing = report.attempts.filter((a) => a.receiptStatus === "missing").length;
+  const invalid = report.attempts.filter(
+    (a) => a.receiptStatus === "invalid" || a.receiptStatus === "duplicate-turn"
+  ).length;
+  const settled = report.attempts.filter((a) => a.settlement).length;
+  const verified = report.attempts.filter(
+    (a) => a.settlement?.outcome === "complete" && a.receipt?.verification === "recorded"
+  ).length;
+  return [
+    `Resident ${line(report.scope.agentKey)} \xB7 ${report.historyComplete ? "lifetime history" : "partial history"}`,
+    `Revisions ${report.fromRevision}\u2013${report.throughRevision} of ${report.scope.throughRevision}${report.nextCursor === null ? "" : ` \xB7 next cursor ${report.nextCursor}`}`,
+    `${report.attempts.length} admitted \xB7 ${settled} settled \xB7 ${verified} ${verified === 1 ? "completion" : "completions"} with recorded verification \xB7 ${report.archivedPursuits.length} archived pursuits`,
+    `Recorded tokens: ${recorded.ownTokens} own \xB7 ${recorded.treeTokens} including descendants (separate totals)`,
+    `Known own cost: $${recorded.ownCostUsd.toFixed(6)}${unknown.ownPriceAttempts ? " (partial)" : ""} \xB7 ${recorded.unpricedOwnTokens} unpriced own tokens \xB7 descendant prices not included`,
+    `Incomplete attempts: ${unknown.ownUsageAttempts} own usage \xB7 ${unknown.treeUsageAttempts} tree usage \xB7 ${unknown.ownPriceAttempts} own price`,
+    ...report.unavailableRevisions.length ? [`Unavailable history revisions: ${report.unavailableRevisions.join(", ")}`] : [],
+    ...missing || invalid || deferred.length ? [
+      `Receipts: ${missing} missing \xB7 ${invalid} invalid \xB7 ${deferred.length} deferred by read allowance`
+    ] : [],
+    ...deferred[0] ? [
+      `Continue deferred receipts: resident inspect --cursor ${deferred[0].revision} --through-revision ${report.scope.throughRevision}`
+    ] : [],
+    "Accounting only; existing limits apply per step. Verification is historical, not a current-source check.",
+    "",
+    ...report.attempts.slice(-20).map((a) => {
+      const state = a.settlement?.outcome ?? (report.historyComplete ? "unsettled" : "settlement outside this view or unresolved");
+      return `${a.claimId} \xB7 step ${a.step} \xB7 ${state} \xB7 ${a.receipt?.ownTokens ?? "?"} own tokens${a.receipt?.usageFinal ? "" : " (partial/unknown)"}
+  ${line(a.objective).slice(0, 180)}`;
+    }),
+    ...report.attempts.length > 20 ? [`Showing latest 20 of ${report.attempts.length} inspected attempts; JSON includes all.`] : []
+  ].join("\n");
+}
+__name(residentInspectionText, "residentInspectionText");
+async function inspectCliResident(resident, throughRevision, options, signal) {
+  const inspection = await inspectResidentConsumption(
+    resident.agenda.activity(throughRevision),
+    residentConsumptionResolver(resident),
+    options,
+    signal
+  );
+  return { inspection, text: residentInspectionText(inspection) };
+}
+__name(inspectCliResident, "inspectCliResident");
+
+// src/integrations/resident/runner-launch.ts
+import { fork } from "node:child_process";
+import { createRequire } from "node:module";
+import { setTimeout as sleep } from "node:timers/promises";
+async function startResidentRunner(options) {
+  const { resident } = options;
+  const existing = readRunner(resident);
+  if (existing && (existing.phase === "reserved" || existing.phase === "running"))
+    throw new Error(
+      `Runner ${existing.instanceId} already owns this resident. Use resident status or stop; a second start cannot reset its limit.`
+    );
+  const agenda = await resident.agenda.read();
+  if (!agenda || agenda.paused || agenda.pursuits.some((p) => p.state.phase === "running"))
+    throw new Error("Starting requires open admission and no unresolved pursuit claims.");
+  const owner = reserveRunner(resident, {
+    mode: "background",
+    maxSteps: options.maxSteps,
+    pauseGeneration: agenda.pauseGeneration ?? 0
+  });
+  const source = (new URL("../", import.meta.url).href + "integrations/resident/runner-launch.js").endsWith(".ts");
+  const worker = new URL(`./runner-worker.${source ? "ts" : "js"}`, new URL("../", import.meta.url).href + "integrations/resident/runner-launch.js");
+  const launch = {
+    version: 1,
+    cwd: resident.cwd,
+    agentKey: resident.agentKey,
+    instanceId: owner.instanceId,
+    config: options.ctx.config,
+    flags: options.flags,
+    toolLoading: options.toolLoading,
+    contextProfile: options.contextProfile,
+    learningDisclosure: options.learningDisclosure,
+    verification: options.verification,
+    maxIdleMs: options.maxIdleMs
+  };
+  let child;
+  try {
+    child = fork(worker, [], {
+      cwd: resident.cwd,
+      env: { ...process.env, NAMZU_HOME: resident.root },
+      detached: true,
+      stdio: ["ignore", "ignore", "ignore", "ipc"],
+      execArgv: source ? ["--import", createRequire(new URL("../", import.meta.url).href + "integrations/resident/runner-launch.js").resolve("tsx")] : []
+    });
+  } catch (error) {
+    finishRunner(resident, owner, "launch_failed");
+    throw error;
+  }
+  return await new Promise((resolve2, reject) => {
+    let settled = false;
+    const finish = /* @__PURE__ */ __name((error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.removeListener("message", message);
+      child.removeListener("exit", exited);
+      if (child.connected) child.disconnect();
+      child.unref();
+      if (error) reject(error);
+      else {
+        try {
+          const current = readRunnerInstance(resident, owner.instanceId);
+          if (!current) throw new Error("Runner startup receipt disappeared.");
+          resolve2(publicRunner(current));
+        } catch (readError) {
+          reject(readError);
+        }
+      }
+    }, "finish");
+    const message = /* @__PURE__ */ __name((raw) => {
+      if (!raw || typeof raw !== "object") return;
+      const value = raw;
+      if (value.instanceId !== owner.instanceId) return;
+      if (value.kind === "error") {
+        finish(
+          new Error(typeof value.message === "string" ? value.message : "Runner startup failed.")
+        );
+      } else if (value.kind === "ready") {
+        child.send(
+          { kind: "go", instanceId: owner.instanceId },
+          (error) => finish(error ?? void 0)
+        );
+      }
+    }, "message");
+    const exited = /* @__PURE__ */ __name(() => finish(
+      new Error(
+        "Resident worker exited before startup was acknowledged. Inspect resident status."
+      )
+    ), "exited");
+    const timer = setTimeout(
+      () => finish(
+        new Error(
+          "Resident startup was not acknowledged. Ownership is retained; inspect resident status before retrying."
+        )
+      ),
+      15e3
+    );
+    child.on("message", message);
+    child.once("exit", exited);
+    child.on("error", (error) => {
+      if (!child.pid) {
+        try {
+          finishRunner(resident, owner, "launch_failed");
+        } catch {
+        }
+      }
+      finish(error);
+    });
+    child.send(launch, (error) => {
+      if (error) finish(error);
+    });
+  });
+}
+__name(startResidentRunner, "startResidentRunner");
+async function residentRunnerStatus(resident) {
+  const record = readRunner(resident);
+  if (!record) return { owner: null, live: null };
+  return {
+    owner: publicRunner(record),
+    live: record.phase === "running" ? await queryRunner(record, "status") : null
+  };
+}
+__name(residentRunnerStatus, "residentRunnerStatus");
+async function stopResidentRunner(resident, options) {
+  const record = options.owner;
+  const waitMs = options.waitMs ?? 5e3;
+  if (!record) return { status: "absent", owner: null };
+  if (record.phase === "stopped") return { status: "drained", owner: publicRunner(record) };
+  if (record.phase === "released")
+    return { status: "unconfirmed", owner: publicRunner(record) };
+  if (record.phase === "running") await queryRunner(record, "stop");
+  const deadline = Date.now() + waitMs;
+  while (true) {
+    const current = readRunnerInstance(resident, record.instanceId);
+    if (current?.phase === "stopped")
+      return { status: "drained", owner: publicRunner(current) };
+    if (!current || current.phase === "released" || Date.now() >= deadline)
+      return { status: "unconfirmed", owner: current ? publicRunner(current) : null };
+    await sleep(Math.min(50, Math.max(1, deadline - Date.now())));
+  }
+}
+__name(stopResidentRunner, "stopResidentRunner");
+
+// src/commands/resident-flags.ts
+var actions = [
+  "add",
+  "status",
+  "inspect",
+  "run",
+  "start",
+  "stop",
+  "release",
+  "pause",
+  "resume",
+  "wake",
+  "reconcile",
+  "archive"
+];
+function integer(value, flag, zero = false) {
+  const parsed = Number(value);
+  if (!/^\d+$/.test(value) || !Number.isSafeInteger(parsed) || parsed < (zero ? 0 : 1))
+    throw new Error(`${flag} requires a ${zero ? "nonnegative" : "positive"} whole number.`);
+  return parsed;
+}
+__name(integer, "integer");
+function parseResidentFlags(raw) {
+  const implicit = raw[0] === void 0 || raw[0].startsWith("-");
+  const action = implicit ? "status" : raw[0];
+  const execution = action === "run" || action === "start";
+  if (!actions.includes(action))
+    throw new Error(`Unknown resident action ${action}. Use: ${actions.join(", ")}.`);
+  const own = /* @__PURE__ */ new Map();
+  const forwarded = [];
+  let executorStopped = false;
+  for (let i = implicit ? 0 : 1; i < raw.length; i++) {
+    const item = raw[i];
+    if (item === "--") {
+      forwarded.push(...raw.slice(i));
+      break;
+    }
+    if (item === "--executor-stopped") {
+      if (executorStopped) throw new Error("Duplicate --executor-stopped.");
+      executorStopped = true;
+      continue;
+    }
+    const [name, ...suffix] = item.split("=");
+    if ([
+      "--cursor",
+      "--through-revision",
+      "--max-revisions",
+      "--agent",
+      "--max-steps",
+      "--max-idle-ms",
+      "--tool-loading",
+      "--context-profile",
+      "--learning-disclosure",
+      "--verify",
+      "--claim",
+      "--revision",
+      "--outcome"
+    ].includes(name)) {
+      if (own.has(name)) throw new Error(`Duplicate ${name}.`);
+      const value = suffix.length ? suffix.join("=") : raw[++i];
+      if (!value || value.startsWith("--")) throw new Error(`${name} requires a value.`);
+      own.set(name, value);
+    } else forwarded.push(item);
+  }
+  const inspectionThroughRevision = own.has("--through-revision") ? integer(own.get("--through-revision") ?? "", "--through-revision") : void 0;
+  const inspectionCursor = own.has("--cursor") ? integer(own.get("--cursor") ?? "", "--cursor") : void 0;
+  const inspectionMaxRevisions = own.has("--max-revisions") ? integer(own.get("--max-revisions") ?? "", "--max-revisions") : void 0;
+  if (action !== "inspect" && (inspectionCursor !== void 0 || inspectionMaxRevisions !== void 0 || inspectionThroughRevision !== void 0))
+    throw new Error("--cursor, --through-revision and --max-revisions apply to resident inspect.");
+  if (inspectionMaxRevisions !== void 0 && inspectionMaxRevisions > 4096)
+    throw new Error("--max-revisions must not exceed 4096.");
+  const run = parseExecFlags(forwarded);
+  if (run.unknown.length) throw new Error(`Unknown option(s): ${run.unknown.join(", ")}.`);
+  if (run.permissionMode && !isPermissionMode(run.permissionMode))
+    throw new Error("Invalid --permission-mode; use prompt, accept-edits, auto, strict or plan.");
+  if (run.gateRetries !== null && (!run.gates.length || !Number.isSafeInteger(run.gateRetries) || run.gateRetries < 1))
+    throw new Error("--gate-retries requires --gate and a whole number above zero.");
+  for (const [flag, value] of [
+    ["--max-iterations", run.maxIterations],
+    ["--token-budget", run.tokenBudget]
+  ])
+    if (value !== null && !Number.isSafeInteger(value))
+      throw new Error(`${flag} exceeds the supported integer range.`);
+  const agent = own.get("--agent") ?? "default";
+  if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(agent))
+    throw new Error(
+      "--agent requires a lowercase name of 1\u201364 letters, digits, underscores or hyphens."
+    );
+  const rawSteps = own.get("--max-steps");
+  const rawIdle = own.get("--max-idle-ms");
+  const rawRevision = own.get("--revision");
+  const toolLoading = own.get("--tool-loading") ?? "eager";
+  const verification = own.get("--verify") ?? null;
+  if (!execution && verification) throw new Error("--verify applies to resident run or start.");
+  const learningDisclosure = own.get("--learning-disclosure") ?? "on-demand";
+  if (learningDisclosure !== "eager" && learningDisclosure !== "on-demand")
+    throw new Error("--learning-disclosure must be eager or on-demand.");
+  if (!execution && own.has("--learning-disclosure"))
+    throw new Error("--learning-disclosure applies to resident run or start.");
+  const contextProfile = own.get("--context-profile") ?? "resident";
+  if (contextProfile !== "resident" && contextProfile !== "interactive")
+    throw new Error("--context-profile must be resident or interactive.");
+  if (!execution && own.has("--context-profile"))
+    throw new Error("--context-profile applies to resident run or start.");
+  if (contextProfile === "interactive" && own.has("--learning-disclosure"))
+    throw new Error("--learning-disclosure requires the resident context profile.");
+  if (toolLoading !== "eager" && toolLoading !== "deferred")
+    throw new Error("--tool-loading must be eager or deferred.");
+  if (!execution && own.has("--tool-loading"))
+    throw new Error("--tool-loading applies to resident run or start.");
+  const maxSteps = rawSteps !== void 0 ? integer(rawSteps, "--max-steps") : null;
+  const maxIdleMs = rawIdle !== void 0 ? integer(rawIdle, "--max-idle-ms", true) : 6e4;
+  if (maxIdleMs > 2147483647) throw new Error("--max-idle-ms exceeds the supported timer range.");
+  const revision = rawRevision !== void 0 ? integer(rawRevision, "--revision") : null;
+  const claim = own.get("--claim") ?? null;
+  const outcome = own.get("--outcome") ?? null;
+  if (outcome !== null && !["wait", "complete", "blocked"].includes(outcome))
+    throw new Error("--outcome must be wait, complete or blocked.");
+  if (run.session || run.resume || run.continueLast || run.waitForProviderMs !== null)
+    throw new Error("Resident work cannot use conversation resume or provider-retry flags.");
+  if (run.json || run.outputSchema !== null)
+    throw new Error(
+      "--json and --output-schema are exec options; resident work does not take them."
+    );
+  if (!execution && (maxSteps !== null || own.has("--max-idle-ms")))
+    throw new Error("--max-steps and --max-idle-ms apply to resident run or start.");
+  if (action === "start" && maxIdleMs === 0)
+    throw new Error("resident start requires --max-idle-ms above zero.");
+  if (!execution && (run.provider || run.model || run.effort || run.permissionMode || run.skipPermissions || run.skills.length || run.gates.length || run.gateRetries !== null || run.maxIterations !== null || run.tokenBudget !== null))
+    throw new Error(
+      "Provider, tool and budget options apply to resident run or start; add does not save execution permissions."
+    );
+  if (action !== "reconcile" && (claim || revision !== null || outcome || executorStopped && action !== "release"))
+    throw new Error("Claim, revision, outcome and executor confirmation apply to reconcile.");
+  if (execution && maxSteps === null)
+    throw new Error(`resident ${action} requires --max-steps <n>.`);
+  if (["status", "inspect", "run", "start", "stop", "pause", "resume"].includes(action) && run.rest.length)
+    throw new Error(`resident ${action} does not take a prompt or pursuit ID.`);
+  if (action === "add" && !run.rest.join(" ").trim())
+    throw new Error("resident add requires an objective.");
+  if (action === "wake" && run.rest.length < 2)
+    throw new Error("resident wake requires a pursuit ID and new evidence.");
+  if (action === "archive" && run.rest.length !== 1)
+    throw new Error("resident archive requires one pursuit ID.");
+  if (action === "release" && (run.rest.length !== 1 || !executorStopped))
+    throw new Error(
+      "resident release requires <runner-id> and --executor-stopped. Stop all prior executors and inspect effects first; pause the resident before release."
+    );
+  if (action === "reconcile" && (run.rest.length < 2 || !claim || revision === null || !outcome || !executorStopped))
+    throw new Error(
+      "reconcile requires <pursuit-id> <inspection-summary>, --claim, --revision, --outcome and --executor-stopped. Stop all prior executors and inspect effects first."
+    );
+  return {
+    action,
+    inspectionCursor,
+    inspectionThroughRevision,
+    inspectionMaxRevisions,
+    agent,
+    maxSteps,
+    maxIdleMs,
+    toolLoading,
+    contextProfile,
+    learningDisclosure,
+    verification,
+    claim,
+    revision,
+    outcome,
+    executorStopped,
+    run
+  };
+}
+__name(parseResidentFlags, "parseResidentFlags");
+
+// src/commands/resident-learning.ts
+import { lstatSync as lstatSync2 } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
+
+// src/integrations/resident/learning-storage.ts
+import { existsSync, lstatSync } from "node:fs";
+import { join as join2 } from "node:path";
+function residentLearningStore(resident, readOnly = false) {
+  const agentRoot = residentDirectoryFor(resident.root, resident.slug, resident.agentKey);
+  const databasePath = join2(agentRoot, "learning.sqlite");
+  const artifactsPath = join2(agentRoot, "artifacts");
+  if (readOnly) {
+    for (const directory of [agentRoot, artifactsPath]) {
+      if (!existsSync(directory)) continue;
+      const entry = lstatSync(directory);
+      if (!entry.isDirectory() || entry.isSymbolicLink())
+        throw new Error(`Learning state requires a real directory: ${directory}`);
+    }
+    if (!existsSync(databasePath)) return null;
+  } else {
+    ensurePrivateStateDirectory(agentRoot, "artifacts");
+  }
+  for (const file of [
+    databasePath,
+    `${databasePath}-journal`,
+    `${databasePath}-wal`,
+    `${databasePath}-shm`
+  ]) {
+    let entry;
+    try {
+      entry = lstatSync(file);
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    if (!entry.isFile() || entry.isSymbolicLink() || entry.nlink !== 1)
+      throw new Error(`Learning database requires a private regular file: ${file}`);
+  }
+  return new SqliteResidentLearningStore({
+    databasePath,
+    artifactsPath,
+    scope: resident,
+    readOnly
+  });
+}
+__name(residentLearningStore, "residentLearningStore");
+
+// src/commands/resident-learning.ts
+var line2 = /* @__PURE__ */ __name((value) => stripVTControlCharacters2(value).replace(/[\p{Cc}\p{Cf}]/gu, " "), "line");
+var preview = /* @__PURE__ */ __name((value) => {
+  const chars = Array.from(line2(value));
+  return chars.length > 240 ? `${chars.slice(0, 240).join("")}\u2026 (full text: --format json)` : chars.join("");
+}, "preview");
+var integer2 = /* @__PURE__ */ __name((value) => {
+  if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)))
+    throw new Error("Expected a nonnegative safe integer.");
+  return Number(value);
+}, "integer");
+function learningSummary(row) {
+  const usage = row.result?.consumption ?? {
+    ...row.recordedUsage,
+    unfinishedStages: 1
+  };
+  const review = row.result?.review;
+  const comparisons = [
+    ["Verification", review?.verification],
+    ["Confirmation", review?.confirmation]
+  ].flatMap(([label, round]) => {
+    if (!round?.tasks.length) return [];
+    const total = round.tasks.reduce((n, t) => n + t.trials, 0);
+    const baseline = round.tasks.reduce((n, t) => n + t.baselinePasses, 0);
+    const candidate = round.tasks.reduce((n, t) => n + t.candidatePasses, 0);
+    const protection = review?.protection?.[label === "Verification" ? "verification" : "confirmation"];
+    return [
+      `  ${label}: baseline ${baseline}/${total} \u2192 candidate ${candidate}/${total}`,
+      ...protection ? [
+        `    Protected tasks: ${protection.status}${protection.missingTasks.length ? ` \xB7 ${protection.missingTasks.length} missing` : ""}${protection.unprovenTasks.length ? ` \xB7 ${protection.unprovenTasks.length} unproven` : ""}${protection.regressedTasks.length ? ` \xB7 ${protection.regressedTasks.length} regressed` : ""}`
+      ] : []
+    ];
+  });
+  return [
+    `${row.cycleId} \xB7 ${row.status} \xB7 ${line2(row.skillName ?? "preflight")}`,
+    `  ${usage.tokens} recorded tokens${usage.unknownTokens || usage.unfinishedStages ? " \xB7 incomplete" : ""} \xB7 ${usage.unknownCosts || usage.unfinishedStages ? "price incomplete or unknown" : `$${usage.costUsd.toFixed(4)}`}`,
+    ...!row.result ? ["  No final receipt; recorded state does not establish a live executor."] : [],
+    ...row.result ? [`  ${line2(row.result.reason)}`] : [],
+    ...comparisons
+  ].join("\n");
+}
+__name(learningSummary, "learningSummary");
+async function residentLearningCommand({
+  ctx,
+  rawArgs
+}) {
+  const execute = rawArgs[0] === "learn";
+  const parser = new Command().exitOverride().configureOutput({ writeOut: /* @__PURE__ */ __name(() => {
+  }, "writeOut"), writeErr: /* @__PURE__ */ __name(() => {
+  }, "writeErr") }).allowExcessArguments(false).argument(execute ? "<experiment.learning.js>" : "[cycle-id]").option("--cwd <path>").option("--agent <name>", "Resident name", "default");
+  if (execute) parser.option("--trust");
+  else
+    parser.option("--events").option("--observations", "Inspect host-scored learning observations").option("--after <sequence>", "", integer2).option("--before <ordinal>", "", integer2).option("--limit <count>", "", integer2);
+  try {
+    parser.parse(rawArgs.slice(1), { from: "user" });
+  } catch (error) {
+    ctx.formatter.error({ message: String(error) });
+    return EXIT_USAGE;
+  }
+  const flags = parser.opts();
+  const target = resolveWorkingDirectory(flags.cwd ?? null);
+  if ("error" in target) {
+    ctx.formatter.error({ message: target.error });
+    return EXIT_USAGE;
+  }
+  const controller = new AbortController();
+  const interrupt = /* @__PURE__ */ __name(() => controller.abort(new Error("Learning experiment interrupted by the operator.")), "interrupt");
+  try {
+    const resident = await lookupResident(target.cwd, flags.agent);
+    if (!resident) {
+      ctx.formatter.print({
+        text: "No resident exists here. Use namzu resident add <objective> first.",
+        cycles: []
+      });
+      return execute ? EXIT_USAGE : 0;
+    }
+    if (!execute) {
+      const id2 = parser.args[0];
+      if (flags.observations) {
+        if (id2 || flags.events || flags.before !== void 0)
+          throw new Error(
+            "--observations uses --after and --limit, without a cycle ID, --events or --before."
+          );
+        const store3 = residentLearningStore(resident, true);
+        const observations = store3 ? await store3.observations({ after: flags.after, limit: flags.limit }) : [];
+        ctx.formatter.print({
+          text: observations.length ? observations.map(
+            (o) => [
+              `${o.ordinal} \xB7 ${line2(o.skillName)} \xB7 ${o.outcome}${o.usageComplete ? "" : " \xB7 usage unresolved"}`,
+              `  ${line2(o.taskKey)} \xB7 ${line2(o.evaluatorRevision)}`,
+              `  ${preview(o.evidence.reason)}`,
+              `  ${o.attemptedCycleId ? `Experiment: ${o.attemptedCycleId}` : "No experiment claimed"}`
+            ].join("\n")
+          ).join("\n\n") : "No learning observations recorded.",
+          observations,
+          nextAfter: observations.at(-1)?.ordinal ?? flags.after ?? 0
+        });
+        return 0;
+      }
+      if ((flags.events || flags.after !== void 0) && !id2)
+        throw new Error("--events and --after require a cycle ID.");
+      if (flags.after !== void 0 && !flags.events) throw new Error("--after requires --events.");
+      if (id2 && flags.before !== void 0) throw new Error("--before applies to the cycle list.");
+      const store2 = residentLearningStore(resident, true);
+      if (!store2) {
+        ctx.formatter.print({
+          text: "No learning experiments recorded.",
+          cycles: []
+        });
+        return 0;
+      }
+      if (id2) {
+        const cycle = await store2.get(id2);
+        if (!cycle) throw new Error("Learning cycle is not retained here.");
+        const artifacts = await store2.artifacts(id2);
+        const events = flags.events ? await store2.events(id2, { after: flags.after, limit: flags.limit }) : void 0;
+        ctx.formatter.print({
+          text: [
+            learningSummary(cycle),
+            ...artifacts.map((a) => `  ${line2(a.name)} \xB7 ${a.bytes} bytes \xB7 ${a.hash}`),
+            ...events?.map(
+              (e) => `  ${e.sequence} \xB7 ${e.kind}${e.stage ? ` \xB7 ${e.stage}` : ""}`
+            ) ?? []
+          ].join("\n"),
+          cycle,
+          artifacts,
+          ...events ? { events, nextAfter: events.at(-1)?.sequence ?? flags.after ?? 0 } : {}
+        });
+      } else {
+        const cycles = await store2.list({
+          before: flags.before,
+          limit: flags.limit
+        });
+        ctx.formatter.print({
+          text: cycles.length ? cycles.map(learningSummary).join("\n\n") : "No learning experiments recorded.",
+          cycles,
+          nextBefore: cycles.at(-1)?.ordinal ?? null
+        });
+      }
+      return 0;
+    }
+    const trust = decideHeadlessTrust({
+      cwd: resident.cwd,
+      trustFlag: flags.trust === true
+    });
+    if (!trust.allowed) {
+      ctx.formatter.error({
+        message: trust.message ?? "Resident directory is not trusted."
+      });
+      return EXIT_UNTRUSTED;
+    }
+    if (trust.cwd !== resident.cwd)
+      throw new Error("Resident execution directory changed its canonical path.");
+    const agenda = await resident.agenda.read();
+    if (!agenda || agenda.paused || agenda.pursuits.some((p) => p.state.phase === "running"))
+      throw new Error("Learning requires an unpaused resident with no running pursuits.");
+    const file = resolve(target.cwd, parser.args[0]);
+    if (!file.endsWith(".learning.js") && !file.endsWith(".learning.mjs"))
+      throw new Error("Choose an explicit .learning.js or .learning.mjs host module.");
+    const entry = lstatSync2(file);
+    if (!entry.isFile() || entry.isSymbolicLink())
+      throw new Error("Learning experiment must be a regular host module, without a symbolic link.");
+    process.on("SIGINT", interrupt);
+    process.on("SIGTERM", interrupt);
+    controller.signal.throwIfAborted();
+    ctx.formatter.info(`Learning experiment: ${line2(file)}`);
+    const module = await import(pathToFileURL(file).href);
+    if (typeof module.default !== "function")
+      throw new Error("Learning module must default-export a host factory.");
+    const store = residentLearningStore(resident);
+    if (!store) throw new Error("Learning storage is unavailable.");
+    const options = await module.default({
+      cwd: resident.cwd,
+      tenantId: resident.tenantId,
+      projectId: resident.projectId,
+      agentKey: resident.agentKey,
+      signal: controller.signal,
+      store
+    });
+    controller.signal.throwIfAborted();
+    const explore = options.explore;
+    const execution = {
+      ...options,
+      agenda: resident.agenda,
+      signal: controller.signal,
+      ...explore ? {
+        explore: /* @__PURE__ */ __name(async (context) => {
+          ctx.formatter.info(`Learning \xB7 ${line2(context.skillName)} \xB7 exploring environment`);
+          return explore(context);
+        }, "explore")
+      } : {},
+      generate: /* @__PURE__ */ __name(async (context) => {
+        ctx.formatter.info(`Learning \xB7 ${line2(context.skillName)} \xB7 generating guidance`);
+        return options.generate(context);
+      }, "generate"),
+      evaluate: /* @__PURE__ */ __name(async (context) => {
+        ctx.formatter.info(`Learning \xB7 ${context.stage}`);
+        return options.evaluate(context);
+      }, "evaluate")
+    };
+    const discovery = "evaluators" in execution ? await runStoredResidentLearningFromObservations(store, execution) : null;
+    const result = "evaluators" in execution ? discovery?.cycle : await runStoredResidentLearningCycle(store, execution);
+    if (!result) {
+      ctx.formatter.print({
+        text: "No eligible unattempted learning observation for the current skills and evaluators.",
+        result: null
+      });
+      return 0;
+    }
+    let saved = null;
+    try {
+      saved = await store.get(result.cycleId);
+    } catch (error) {
+      ctx.formatter.error({
+        message: `Result received; journal inspection failed: ${String(error)}`
+      });
+    }
+    ctx.formatter.print({
+      text: [
+        saved ? learningSummary({ ...saved, status: result.status, result }) : `${result.cycleId} \xB7 ${result.status}: ${line2(result.reason)}`,
+        ...!result.auditComplete ? [
+          "The journal is incomplete. Inspect the exact skill evidence before retrying; do not replay the experiment automatically."
+        ] : []
+      ].join("\n"),
+      result,
+      journal: saved,
+      databasePath: store.databasePath
+    });
+    return result.status === "activated" && result.auditComplete ? 0 : result.status === "cancelled" ? 130 : ["rejected", "inconclusive"].includes(result.status) ? 2 : 1;
+  } catch (error) {
+    ctx.formatter.error({
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return controller.signal.aborted ? 130 : 1;
+  } finally {
+    process.off("SIGINT", interrupt);
+    process.off("SIGTERM", interrupt);
+  }
+}
+__name(residentLearningCommand, "residentLearningCommand");
+
+// src/commands/resident.ts
+var line3 = /* @__PURE__ */ __name((value) => stripVTControlCharacters3(value).replace(/[\p{Cc}\p{Cf}]/gu, " "), "line");
+function residentStatus(resident, state, message, runner) {
+  const unresolved = state.pursuits.filter((p) => p.state.phase === "running");
+  const live = runner?.live?.kind === "responsive" ? runner.live : null;
+  const responsive = live !== null;
+  const text2 = [
+    `Resident \xB7 ${resident.agentKey}`,
+    `Directory: ${line3(resident.cwd)}`,
+    `Admission: ${state.paused ? "paused" : "open"}${unresolved.length ? responsive ? " \xB7 a pursuit is admitted" : " \xB7 retained work needs inspection" : ""}`,
+    ...runner?.owner ? [
+      `Runner: ${live ? live.phase : runner.owner.phase === "running" ? "unresponsive; state retained" : runner.owner.phase} \xB7 ${runner.owner.mode}`,
+      `  ${runner.owner.instanceId} \xB7 ${runner.owner.maxSteps} step(s) authorized${runner.owner.pid ? ` \xB7 PID ${runner.owner.pid}` : ""}`,
+      ...live ? [`  ${live.stepsStarted} step(s) started in this invocation`] : [],
+      ...runner.owner.outcome ? [`  Last outcome: ${line3(runner.owner.outcome)}`] : []
+    ] : [],
+    ...message ? ["", message] : [],
+    "",
+    ...state.pursuits.flatMap((p) => [
+      `${p.state.phase} \xB7 ${line3(p.state.objective)}`,
+      `  ${p.id} \xB7 ${p.state.stepsAdmitted} step(s) admitted`,
+      ...p.state.summary ? [`  ${line3(p.state.summary)}`] : [],
+      ...p.state.wakeEvidence ? [`  Pending evidence: ${p.state.wakeEvidence.length} input(s) retained until settlement.`] : [],
+      ...p.state.phase === "waiting" ? [
+        `  ${p.state.wakeAt === null ? "Waiting for evidence; use resident wake." : p.state.wakeAt <= Date.now() ? responsive ? "Ready for the active runner." : "Ready for the next authorized run." : `Next step: ${new Date(p.state.wakeAt).toISOString()}`}`
+      ] : [],
+      ...p.state.claimId ? [
+        `  Claim: ${p.state.claimId} \xB7 revision ${p.state.revision}`,
+        `  Inspect attempt records: ${line3(resident.artifactsRoot)}/${p.state.claimId}`
+      ] : []
+    ]),
+    ...state.pursuits.length ? [] : ["No active pursuits."],
+    ...unresolved.length && !responsive ? [
+      "",
+      "A retained claim does not establish whether its executor is still alive.",
+      "Stop prior executors and inspect effects before resident reconcile."
+    ] : []
+  ].join("\n");
+  return {
+    text: text2,
+    agent: resident.agentKey,
+    cwd: resident.cwd,
+    agenda: state,
+    ...runner ? { runner } : {},
+    ...message ? { message } : {}
+  };
+}
+__name(residentStatus, "residentStatus");
+function pursuit(state, id2) {
+  const found = state.pursuits.find((p) => p.id === id2);
+  if (!found) throw new Error(`Unknown active pursuit: ${id2}`);
+  return found;
+}
+__name(pursuit, "pursuit");
+async function readAgenda(resident) {
+  const state = await resident.agenda.read();
+  if (!state) throw new Error("Resident agenda is missing; no saved result can be reported.");
+  return state;
+}
+__name(readAgenda, "readAgenda");
+async function closeAdmission(resident, initial) {
+  let state = initial;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await resident.agenda.setPaused(state, true);
+      return;
+    } catch (error) {
+      if (!(error instanceof ResidentConflictError) || attempt >= 7) throw error;
+      state = await readAgenda(resident);
+    }
+  }
+}
+__name(closeAdmission, "closeAdmission");
+var residentCommand = {
+  name: "resident",
+  description: "Manage persistent work and explicitly authorized resident runners (experimental)",
+  passThrough: true,
+  help: [
+    "Usage: namzu resident <action> [options]",
+    "",
+    "  add <objective>          Save work without starting a model",
+    "  inspect                  Inspect lifetime usage and evidence (--cursor, --through-revision, --max-revisions)",
+    "  learn <file.learning.js> Run one explicitly selected executable learning experiment (--trust, --cwd, --agent)",
+    "  learning [cycle-id]      Inspect experiments or --observations (--events, --after, --before, --limit)",
+    "  status                   Show saved work and unresolved claims (default action)",
+    "  run --max-steps <n>       Continue due work in this foreground process",
+    "  run/start --verify <file> Require configured JSON claims before completion (host file reads)",
+    "  start --max-steps <n>     Start a managed background runner; retain its limit while idle",
+    "  stop                     Close admission and wait briefly for runner drainage",
+    "  release <runner-id>      Release inspected stale ownership; requires --executor-stopped",
+    "  pause                    Close admission and request interruption of active runners",
+    "  resume                   Reopen admission; does not start work or clear claims",
+    "  wake <id> <evidence>      Make a waiting pursuit due using new evidence",
+    "  archive <id>             Retire a terminal pursuit, preserving its history",
+    "  reconcile <id> <summary> Record inspected effects for an exact interrupted claim",
+    "",
+    "Common: --cwd <path>, --agent <name> (default: default).",
+    "The first add binds the execution directory; later launches keep that directory.",
+    "Add, run and start require folder trust, or --trust for this invocation.",
+    "",
+    "Run options: --provider <id>, --model <id>, --effort <level>,",
+    "  --permission-mode <mode> (default: plan, read-only), --skills <a,b>,",
+    "  --max-iterations <n>, --token-budget <n> (limits apply per SDK step),",
+    "  --tool-loading eager|deferred (default: eager; defer optional schemas per step),",
+    "  --learning-disclosure on-demand|eager (default: on-demand; evaluated skills),",
+    "  --context-profile resident|interactive (default: resident; bounded-step guidance),",
+    "  --gate <command>, --gate-retries <n>, --max-idle-ms <n> (default: 60000).",
+    "Run and start require a finite --max-steps. No OS service is installed.",
+    "Start survives the launching terminal; it stops at that limit, pause, failure or stop.",
+    "For start, --max-idle-ms is a positive local idle check interval; idle does not exit.",
+    "Status contacts the exact runner locally; no recorded PID is blindly signalled.",
+    "Idle waits use local storage checks and spend no model calls.",
+    "",
+    "Reconcile also requires --claim <uuid> --revision <n> --outcome wait|complete|blocked",
+    "  --executor-stopped. This confirms all old executors stopped and effects were",
+    "  inspected; put the evidence in <summary>. Pause the resident first.",
+    "  A wait outcome rests indefinitely; use wake to supply new evidence.",
+    "Release requires prior pause and confirmation all previous executors stopped.",
+    "An unreachable runner is not proof it stopped. Release never reconciles a pursuit.",
+    "",
+    "Pause acknowledges durable admission closure, not completed tool cancellation.",
+    "Interrupted, failed or unfinished steps keep their claim and are never replayed automatically.",
+    "Continuation uses the saved summary and approved learning, not a restored chat transcript.",
+    "Exit: 0 for an operation/clean bounded run, 1 for unresolved or failed work,",
+    "  64 for invalid arguments, 77 for untrusted execution, 78 for invalid run config,",
+    "  130 for cancellation. A clean run does not mean every pursuit is complete."
+  ].join("\n"),
+  handler: /* @__PURE__ */ __name(async ({ ctx: bootstrap, rawArgs }) => {
+    if (rawArgs[0] === "learn" || rawArgs[0] === "learning")
+      return residentLearningCommand({ ctx: bootstrap, rawArgs });
+    let flags;
+    try {
+      flags = parseResidentFlags(rawArgs);
+    } catch (error) {
+      bootstrap.formatter.error({
+        message: String(error instanceof Error ? error.message : error)
+      });
+      return EXIT_USAGE;
+    }
+    const resolved = resolveWorkingDirectory(flags.run.cwd);
+    if ("error" in resolved) {
+      bootstrap.formatter.error({ message: resolved.error });
+      return EXIT_USAGE;
+    }
+    let resident = null;
+    try {
+      resident = await lookupResident(resolved.cwd, flags.agent);
+      if (["status", "inspect"].includes(flags.action) && !resident) {
+        bootstrap.formatter.print({
+          text: `No resident named ${flags.agent} in this project. Use namzu resident add <objective>.`,
+          agent: flags.agent,
+          agenda: null
+        });
+        return 0;
+      }
+      if (flags.action === "add" || flags.action === "run" || flags.action === "start") {
+        const target = resolveWorkingDirectory(resident?.cwd ?? resolved.cwd);
+        if ("error" in target) throw new Error(target.error);
+        const trust = decideHeadlessTrust({
+          cwd: target.cwd,
+          trustFlag: flags.run.trust
+        });
+        if (!trust.allowed) {
+          bootstrap.formatter.error({
+            message: trust.message ?? "Resident directory is not trusted."
+          });
+          return EXIT_UNTRUSTED;
+        }
+        if (resident && trust.cwd !== resident.cwd)
+          throw new Error(
+            "Resident execution directory no longer resolves to its saved canonical path. Restore the original directory before running this resident."
+          );
+        if (flags.action === "add") resident = await createResident(trust.cwd, flags.agent);
+      }
+      if (!resident) throw new Error(`No resident named ${flags.agent}. Add a pursuit first.`);
+      let state = await resident.agenda.read();
+      if (!state)
+        throw new Error(
+          "Resident binding exists but its agenda is missing; repeat add to initialize it."
+        );
+      let message;
+      switch (flags.action) {
+        case "add": {
+          const added = await resident.agenda.add(state, flags.run.rest.join(" "));
+          message = `Saved ${added.id}.`;
+          break;
+        }
+        case "status":
+          break;
+        case "inspect": {
+          const throughRevision = flags.inspectionThroughRevision ?? state.revision;
+          if (throughRevision > state.revision)
+            throw new Error("Inspection boundary is ahead of saved history.");
+          bootstrap.formatter.print(
+            await inspectCliResident(resident, throughRevision, {
+              cursor: flags.inspectionCursor,
+              maxRevisions: flags.inspectionMaxRevisions
+            })
+          );
+          return 0;
+        }
+        case "stop": {
+          const owner = readRunner(resident);
+          await closeAdmission(resident, state);
+          const stopped = await stopResidentRunner(resident, { owner });
+          state = await readAgenda(resident);
+          const text2 = stopped.status === "drained" ? "The observed runner drained. Inspect current admission and any retained pursuit claim below." : stopped.status === "absent" ? "Admission closed. No managed runner is recorded; other executors are not certified stopped." : "Interruption requested; runner drainage is not confirmed. Inspect status before recovery.";
+          bootstrap.formatter.print({
+            ...residentStatus(resident, state, text2, await residentRunnerStatus(resident)),
+            stop: stopped
+          });
+          return stopped.status === "unconfirmed" ? 1 : 0;
+        }
+        case "release": {
+          if (!state.paused)
+            throw new Error("Pause the resident before releasing inspected runner ownership.");
+          const owner = readRunner(resident);
+          if (!owner || owner.instanceId !== flags.run.rest[0])
+            throw new Error("Runner ID does not match current ownership. Inspect status again.");
+          if (owner.phase === "running" && (await queryRunner(owner, "status")).kind === "responsive")
+            throw new Error(
+              "This runner still responds. Use resident stop and wait for drainage before recovery."
+            );
+          releaseRunner(resident, owner);
+          message = "Inspected runner ownership released. Pursuit claims and admission are unchanged; reconcile interrupted work separately.";
+          break;
+        }
+        case "pause":
+          await closeAdmission(resident, state);
+          message = "Admission closed; interruption requested. Active tools may still be stopping.";
+          break;
+        case "resume":
+          if (state.pursuits.some((p) => p.state.phase === "running"))
+            throw new Error("Inspect and reconcile unresolved claims before reopening admission.");
+          await resident.agenda.setPaused(state, false);
+          message = "Admission reopened. No work started; invoke resident run or start explicitly.";
+          break;
+        case "wake": {
+          const selected = pursuit(state, flags.run.rest[0]);
+          await resident.agenda.wake(
+            selected.id,
+            selected.state,
+            flags.run.rest.slice(1).join(" "),
+            Date.now()
+          );
+          message = "New evidence saved; pursuit is due on the next authorized run.";
+          break;
+        }
+        case "archive":
+          await resident.agenda.archive(state, {
+            pursuitIds: [pursuit(state, flags.run.rest[0]).id]
+          });
+          message = "Terminal pursuit archived; immutable history retained.";
+          break;
+        case "reconcile": {
+          if (!state.paused)
+            throw new Error("Pause the resident before reconciling inspected effects.");
+          const selected = pursuit(state, flags.run.rest[0]);
+          if (selected.state.phase !== "running" || selected.state.claimId !== flags.claim || selected.state.revision !== flags.revision)
+            throw new Error(
+              "Claim or revision does not match the current unresolved pursuit; inspect status again."
+            );
+          const summary = flags.run.rest.slice(1).join(" ");
+          const decision = flags.outcome === "wait" ? { kind: "wait", summary, wakeAt: null } : { kind: flags.outcome, summary };
+          await resident.agenda.execution(selected.id).settle(selected.state, decision, Date.now());
+          message = "Inspection recorded against the exact claim. Resident remains paused.";
+          break;
+        }
+        case "run":
+        case "start": {
+          if (flags.maxSteps === null) throw new Error("Resident execution requires --max-steps.");
+          const ctx = resolveTrustedProjectContext(bootstrap, resident.cwd);
+          const sessions = await openSessions(resident.cwd);
+          if (sessions.projectId !== resident.projectId || sessions.tenantId !== resident.tenantId)
+            throw new Error(
+              "Resident execution directory no longer belongs to its bound project and tenant."
+            );
+          const { createResidentSessionStep } = await import("./session-step-2HJSIJNN.js");
+          const verification = flags.verification ? await loadResidentVerification(flags.verification, resident.cwd) : void 0;
+          const step = createResidentSessionStep({
+            agenda: resident.agenda,
+            ctx,
+            cwd: resident.cwd,
+            sessions,
+            flags: flags.run,
+            toolLoading: flags.toolLoading,
+            contextProfile: flags.contextProfile,
+            learningDisclosure: flags.learningDisclosure,
+            verification,
+            artifactsRoot: resident.artifactsRoot,
+            projectSlug: resident.slug
+          });
+          if (flags.action === "start") {
+            const owner = await startResidentRunner({
+              resident,
+              ctx,
+              flags: flags.run,
+              toolLoading: flags.toolLoading,
+              contextProfile: flags.contextProfile,
+              learningDisclosure: flags.learningDisclosure,
+              verification,
+              maxSteps: flags.maxSteps,
+              maxIdleMs: flags.maxIdleMs
+            });
+            state = await readAgenda(resident);
+            ctx.formatter.print({
+              ...residentStatus(
+                resident,
+                state,
+                "Background runner started. Use resident status to inspect it and resident stop to drain it.",
+                await residentRunnerStatus(resident)
+              ),
+              started: owner
+            });
+            return 0;
+          }
+          const existing = readRunner(resident);
+          if (existing && ["reserved", "running"].includes(existing.phase))
+            throw new Error(
+              "A resident runner already owns this agenda. Inspect status and stop it before another turn."
+            );
+          const controller = new AbortController();
+          const interrupt = /* @__PURE__ */ __name(() => controller.abort(new Error("Resident foreground invocation interrupted.")), "interrupt");
+          process.once("SIGINT", interrupt);
+          process.once("SIGTERM", interrupt);
+          try {
+            const result = state.paused || state.pursuits.some((p) => p.state.phase === "running") ? {
+              status: state.paused ? "paused" : "unresolved",
+              stepsSettled: 0,
+              nextWakeAt: null
+            } : await runOwnedResident({
+              resident,
+              owner: reserveRunner(resident, {
+                mode: "foreground",
+                maxSteps: flags.maxSteps,
+                pauseGeneration: state.pauseGeneration ?? 0
+              }),
+              step,
+              signal: controller.signal,
+              keepAlive: false,
+              maxIdleMs: flags.maxIdleMs
+            });
+            state = await readAgenda(resident);
+            const status = residentStatus(
+              resident,
+              state,
+              void 0,
+              await residentRunnerStatus(resident)
+            );
+            ctx.formatter.print({
+              ...status,
+              execution: result,
+              text: `${status.text}
+
+Run: ${result.status} \xB7 ${result.stepsSettled} step(s) settled`
+            });
+            return result.status === "cancelled" ? 130 : ["unresolved", "contended"].includes(result.status) || state.pursuits.some((p) => p.state.phase === "running") ? 1 : 0;
+          } finally {
+            process.removeListener("SIGINT", interrupt);
+            process.removeListener("SIGTERM", interrupt);
+          }
+        }
+      }
+      state = await readAgenda(resident);
+      const runner = await residentRunnerStatus(resident);
+      if (flags.action === "add") {
+        message += runner.live?.kind === "responsive" ? " Due work is available to the current runner within its remaining authorization." : runner.owner && ["running", "reserved"].includes(runner.owner.phase) ? " Runner ownership is retained; inspect resident status before execution." : " Continue with namzu resident run --max-steps <n> or resident start --max-steps <n>.";
+      }
+      bootstrap.formatter.print(residentStatus(resident, state, message, runner));
+      return 0;
+    } catch (error) {
+      bootstrap.formatter.error({
+        message: error instanceof Error ? error.message : String(error)
+      });
+      if (resident) {
+        try {
+          const state = await resident.agenda.read();
+          if (state)
+            bootstrap.formatter.print(
+              residentStatus(resident, state, void 0, await residentRunnerStatus(resident))
+            );
+        } catch {
+        }
+      }
+      return error instanceof ConfigLoadError || error instanceof ConfigValueError ? EXIT_BAD_CONFIG : 1;
+    }
+  }, "handler")
+};
+export {
+  residentCommand,
+  residentStatus
+};
+//# sourceMappingURL=resident-7D6IM5LP.js.map