@corenel/cli 0.8.0 → 0.9.0

package/README.md

@@ -1,68 +1,77 @@
-# @corenel/cli
-
-The Corenel CLI — runs the host-agnostic agent harness in Node, in-process (no
-transport). Early/beta: the headless proof the kernel runs outside the browser.
-
-```bash
-npx @corenel/cli
-```
-
-Requires Node 22+. Bring your provider key via the environment.
-
-Running `corenel` with no command opens an interactive agent in the current
-directory. On a terminal it opens the full terminal face; when output is piped,
-under `TERM=dumb`, in CI, or with `--no-tui`, it falls back to a plain
-line-by-line loop. `--tui` demands the full face and fails rather than falling
-back. `--resume` reopens the last conversation.
-
-Assistant replies render as markdown. More verbs (`run` / `ask` / `chat` /
-`login`, and `start --sidecar`) are in progress.
-
-## Releasing
-
-`@corenel/term` (the terminal face) is a real runtime dependency, not bundled
-into `dist/main.js` -- see the note at the top of `build.mjs`. (`dist/cli.js`,
-the bin, is only a Node >=22 check that then imports `main.js`.) `@corenel/term`'s
-own dist is bundled but keeps `@corenel/harness` and `@corenel/protocol`
-EXTERNAL (see `packages/term/build.mjs`) -- both the CLI and term import the
-harness directly, and they must resolve to the SAME installed copy, or the
-`llm-execution` feature guard and `--debug` logging silently apply to the
-wrong module instance. That makes all four packages real runtime dependencies
-of each other, and publish order matters:
-
-    pnpm --filter @corenel/protocol build && pnpm --filter @corenel/protocol publish
-    pnpm --filter @corenel/harness  build && pnpm --filter @corenel/harness  publish
-    pnpm --filter @corenel/term     build && pnpm --filter @corenel/term     publish
-    pnpm --filter @corenel/cli      build && pnpm --filter @corenel/cli      publish
-
-Publishing any package against an unpublished dependency yields one that
-cannot install at all, so `npx @corenel/cli` fails before any verb runs.
-
-Publish with **pnpm, never npm**: this CLI depends on `@corenel/term` as
-`workspace:*`, and pnpm rewrites the `workspace:` protocol to a real version at
-pack/publish time while npm ships it verbatim -- an `npm publish` from this
-workspace produces a manifest whose install fails with
-`EUNSUPPORTEDPROTOCOL / Unsupported URL Type "workspace:"`, which is the very
-breakage this section exists to prevent.
-
-**All four versions must be bumped and published together, in the order
-above, every release -- even one that only touches a single package.** pnpm
-rewrites every `workspace:*` dependency to the EXACT current version of that
-dependency at pack time. All four packages are pinned to the same harness
-version today, so a normal `npm install` of `@corenel/cli` resolves to one
-harness copy. Bump `@corenel/harness` and publish a new `@corenel/term`
-without also republishing `@corenel/cli`, and the tree that installs
-`@corenel/cli` gets the OLD harness version nested under it (frozen into the
-manifest `@corenel/cli` published against) plus the NEW harness version
-hoisted at the top level for `@corenel/term` -- two separate harness module
-instances again, silently. That is exactly the bug this section's ordering
-exists to prevent (see `harnessSingleInstance.test.ts` in this package's
-`test/`): `registerGuard()`/`setAgentLogging()` calls made through one
-instance configure a module the other never reads, so the `llm-execution`
-feature gate silently stops running and `--debug` logging can't be turned
-off. Every test in this repo stays green when that happens, because the
-in-repo workspace is symlinked (one instance by construction) and the
-build-output regression test only exercises that same symlinked layout --
-neither one can see a real, version-skewed `npm install`.
-
-Licensed under Elastic-2.0.
+# @corenel/cli
+
+The Corenel CLI — runs the host-agnostic agent harness in Node, in-process (no
+transport). Early/beta: the headless proof the kernel runs outside the browser.
+
+```bash
+npx @corenel/cli
+```
+
+Requires Node 22+. Bring your provider key via the environment.
+
+Running `corenel` with no command opens an interactive agent in the current
+directory. On a terminal it opens the full terminal face; when output is piped,
+under `TERM=dumb`, in CI, or with `--no-tui`, it falls back to a plain
+line-by-line loop. `--tui` demands the full face and fails rather than falling
+back. `--resume` reopens the last conversation.
+
+Assistant replies render as markdown. More verbs (`run` / `ask` / `chat` /
+`login`, and `start --sidecar`) are in progress.
+
+The API base is `--base`, then `CORENEL_API_BASE`, then the base recorded at
+`corenel login`, then `https://api.corenel.ai/api`. Run from source
+(`tsx src/cli.ts`), that last default becomes the local API
+(`http://localhost:3010/api`) instead; `corenel auth` and `corenel doctor`
+say so, and a `login` from source records the local base on its credential.
+`--base` and `CORENEL_API_BASE` turn that off, and a recorded login base wins over
+it; to move a credential between production and the local API, run
+`corenel logout` before `corenel login`.
+
+## Releasing
+
+`@corenel/term` (the terminal face) is a real runtime dependency, not bundled
+into `dist/main.js` -- see the note at the top of `build.mjs`. (`dist/cli.js`,
+the bin, is only a Node >=22 check that then imports `main.js`.) `@corenel/term`'s
+own dist is bundled but keeps `@corenel/harness` and `@corenel/protocol`
+EXTERNAL (see `packages/term/build.mjs`) -- both the CLI and term import the
+harness directly, and they must resolve to the SAME installed copy, or the
+`llm-execution` feature guard and `--debug` logging silently apply to the
+wrong module instance. That makes all four packages real runtime dependencies
+of each other, and publish order matters:
+
+    pnpm --filter @corenel/protocol build && pnpm --filter @corenel/protocol publish
+    pnpm --filter @corenel/harness  build && pnpm --filter @corenel/harness  publish
+    pnpm --filter @corenel/term     build && pnpm --filter @corenel/term     publish
+    pnpm --filter @corenel/cli      build && pnpm --filter @corenel/cli      publish
+
+Publishing any package against an unpublished dependency yields one that
+cannot install at all, so `npx @corenel/cli` fails before any verb runs.
+
+Publish with **pnpm, never npm**: this CLI depends on `@corenel/term` as
+`workspace:*`, and pnpm rewrites the `workspace:` protocol to a real version at
+pack/publish time while npm ships it verbatim -- an `npm publish` from this
+workspace produces a manifest whose install fails with
+`EUNSUPPORTEDPROTOCOL / Unsupported URL Type "workspace:"`, which is the very
+breakage this section exists to prevent.
+
+**All four versions must be bumped and published together, in the order
+above, every release -- even one that only touches a single package.** pnpm
+rewrites every `workspace:*` dependency to the EXACT current version of that
+dependency at pack time. All four packages are pinned to the same harness
+version today, so a normal `npm install` of `@corenel/cli` resolves to one
+harness copy. Bump `@corenel/harness` and publish a new `@corenel/term`
+without also republishing `@corenel/cli`, and the tree that installs
+`@corenel/cli` gets the OLD harness version nested under it (frozen into the
+manifest `@corenel/cli` published against) plus the NEW harness version
+hoisted at the top level for `@corenel/term` -- two separate harness module
+instances again, silently. That is exactly the bug this section's ordering
+exists to prevent (see `harnessSingleInstance.test.ts` in this package's
+`test/`): `registerGuard()`/`setAgentLogging()` calls made through one
+instance configure a module the other never reads, so the `llm-execution`
+feature gate silently stops running and `--debug` logging can't be turned
+off. Every test in this repo stays green when that happens, because the
+in-repo workspace is symlinked (one instance by construction) and the
+build-output regression test only exercises that same symlinked layout --
+neither one can see a real, version-skewed `npm install`.
+
+Licensed under Elastic-2.0.

package/dist/main.js

@@ -15259,8 +15259,8 @@ var require_precompile = __commonJS({
         fs6.readdirSync(dir).forEach(function(file) {
           var filepath = path.join(dir, file);
           var subpath = filepath.substr(path.join(input, "/").length);
-          var stat = fs6.statSync(filepath);
-          if (stat && stat.isDirectory()) {
+          var stat2 = fs6.statSync(filepath);
+          if (stat2 && stat2.isDirectory()) {
             subpath += "/";
             if (!match(subpath, opts.exclude)) {
               addTemplates(filepath);
@@ -16439,8 +16439,8 @@ ${yamlContent}` : yamlContent;
         if (resolvedInheritsRef.startsWith("./") || resolvedInheritsRef.startsWith("../") || resolvedInheritsRef.startsWith("/") || !resolvedInheritsRef.startsWith("@") && isPrompdFile(resolvedInheritsRef)) {
           const sourceDir = context.fileSystem.dirname(context.sourceFile);
           const parentPath = context.fileSystem.resolve(sourceDir, resolvedInheritsRef);
-          const fileExists = await context.fileSystem.exists(parentPath);
-          if (!fileExists) {
+          const fileExists2 = await context.fileSystem.exists(parentPath);
+          if (!fileExists2) {
             const location = context.findLocation(/inherits:/);
             context.addDiagnostic({
               message: `Inherited file not found: "${resolvedInheritsRef}" (resolved to: ${parentPath})`,
@@ -16467,8 +16467,8 @@ ${yamlContent}` : yamlContent;
               }
               const packagePath = await this.resolvePackage(context, packageRef);
               const fullFilePath = resolvePackageFile(packagePath, filePathInPackage);
-              const fileExists = await context.fileSystem.exists(fullFilePath);
-              if (!fileExists) {
+              const fileExists2 = await context.fileSystem.exists(fullFilePath);
+              if (!fileExists2) {
                 const location = context.findLocation(/inherits:/);
                 context.addDiagnostic({
                   message: `Inherited file not found in package: "${filePathInPackage}" (package: ${packageRef})`,
@@ -22704,7 +22704,7 @@ var require_websocket_server = __commonJS({
 init_tools_node();
 import { runAgent as runAgent2 } from "@corenel/harness/core/loop";
 import { createChatClient as createChatClient2, setGatewayBase as setGatewayBase2 } from "@corenel/harness/providers/gateway";
-import { resolveContextWindow as resolveContextWindow2, resolveContextWindowWithHydration } from "@corenel/harness/providers/contextWindow";
+import { resolveContextWindow as resolveContextWindow3, resolveContextWindowWithHydration } from "@corenel/harness/providers/contextWindow";
 import { basename as basename5 } from "node:path";
 import { randomUUID } from "node:crypto";
 import { allTools as allTools3 } from "@corenel/harness/tools/builtins";
@@ -22721,9 +22721,9 @@ function configWorkspaceRoot(base) {
 
 // src/cli.ts
 import { FileRecallStore, UNATTACHED_SESSION } from "@corenel/harness/sessions/fileRecallStore";
-import { makeCheckpointStore } from "@corenel/harness/sessions/checkpointStore";
+import { makeSessionFoldStorage } from "@corenel/harness/sessions/foldStorage";
 import { makeSummarizer } from "@corenel/harness/core/summarize";
-import { stateDirName as stateDirName7, sessionsRoot } from "@corenel/protocol";
+import { stateDirName as stateDirName7, sessionsRoot, isSourceRun } from "@corenel/protocol";
 import { PermissionService as PermissionService6 } from "@corenel/harness/guardrail/permission-service";
 
 // src/nodeContext.ts
@@ -24918,6 +24918,7 @@ import { createChatClient, setGatewayBase } from "@corenel/harness/providers/gat
 // src/apiBase.ts
 init_tools_node();
 import { DEFAULT_API_BASE as DEFAULT_API_BASE2 } from "@corenel/protocol";
+import { DEV_PROFILE } from "@corenel/protocol";
 var InvalidApiBaseError = class extends Error {
   constructor(value, why) {
     super(`invalid API base ${JSON.stringify(value)} -- ${why}`);
@@ -24931,12 +24932,34 @@ function isLoopback(hostname2) {
   return h === "localhost" || h === "127.0.0.1" || h === "::1" || h.endsWith(".localhost");
 }
 var warnedCleartext = false;
+var sourceRunDefault = false;
+function setSourceRun(sourceRun) {
+  sourceRunDefault = sourceRun;
+}
+function applySourceRunDevBase(resolved, sourceRun) {
+  if (!sourceRun || resolved.source !== "default") return resolved;
+  return { base: DEV_PROFILE.apiBase, source: "dev-profile" };
+}
+function cliDevRelayBases(resolved, sourceRun = sourceRunDefault) {
+  if (resolved.source === "dev-profile") return [resolved.base];
+  if (sourceRun && resolved.source === "credential" && resolved.base.replace(/\/+$/, "") === DEV_PROFILE.apiBase) return [resolved.base];
+  return [];
+}
+function apiBaseNote(source) {
+  return source === "dev-profile" ? "dev profile: running from source" : void 0;
+}
 async function apiBase(explicit, opts = {}) {
-  const resolved = await resolveApiBase({
-    explicit,
-    env: opts.env ?? process.env,
-    ...opts.stateDir ? { stateDir: opts.stateDir } : {}
-  });
+  return (await resolveCliApiBase(explicit, opts)).base;
+}
+async function resolveCliApiBase(explicit, opts = {}) {
+  const resolved = applySourceRunDevBase(
+    await resolveApiBase({
+      explicit,
+      env: opts.env ?? process.env,
+      ...opts.stateDir ? { stateDir: opts.stateDir } : {}
+    }),
+    opts.sourceRun ?? sourceRunDefault
+  );
   const value = resolved.base;
   let url;
   try {
@@ -24954,7 +24977,7 @@ async function apiBase(explicit, opts = {}) {
 `
     );
   }
-  return value;
+  return resolved;
 }
 
 // src/runAgent.ts
@@ -25270,7 +25293,9 @@ function helpText(version2) {
     "  --model <id>       model for this turn (default gpt-4o-mini)",
     "  --base <url>       API base (default https://api.corenel.ai/api, or CORENEL_API_BASE)",
     "  --policy <name|path>  a builtin policy name (e.g. read-only) or a policy YAML file;",
-    "                     default is a project/user policy.yaml if one exists, else standard",
+    "                     default is the per-project policy (policies/ws-<id>.yaml in your home",
+    "                     state dir), else the user policy.yaml there, else standard. A",
+    "                     policy.yaml inside the project folder is ignored.",
     "  --allow-mutations  allow write/shell/other mutating tools (run/run-agent refuse them",
     "                     outright without this; interactively it skips the per-command",
     "                     prompt instead). --allow-shell still works as an alias.",
@@ -25355,23 +25380,27 @@ async function authState(resolve4 = (env2) => resolveNodeCredential({ env: env2
   const source = r.source === "env" ? "env" : "file";
   return { source, path: r.path ?? authTokenPath(), hint: hintOf(r.token) };
 }
-function describeAuth(s, base) {
+function describeAuth(s, base, source) {
+  const note = source ? apiBaseNote(source) : void 0;
+  const apiLine = `  api    ${base}${note ? `  (${note})` : ""}`;
   if (s.source === "none") {
     return [
       "Not signed in.",
       `  Run \`corenel login\`, or set CORENEL_TOKEN=<token>.`,
-      `  Token would be stored at ${s.path}`
-    ].join("\n");
+      `  Token would be stored at ${s.path}`,
+      note ? apiLine : null
+    ].filter(Boolean).join("\n");
   }
   return [
     `Signed in (${s.source === "env" ? "CORENEL_TOKEN environment variable" : s.path}).`,
     `  token  ${s.hint}`,
-    `  api    ${base}`,
+    apiLine,
     s.source === "env" ? "  NOTE: the environment wins over any stored token, so `corenel logout` will not change this." : null
   ].filter(Boolean).join("\n");
 }
 async function runAuth(out = (s) => process.stdout.write(s)) {
-  out(`${describeAuth(await authState(), await apiBase())}
+  const { base, source } = await resolveCliApiBase();
+  out(`${describeAuth(await authState(), base, source)}
 `);
 }
 async function runLogout(out = (s) => process.stdout.write(s)) {
@@ -25721,17 +25750,19 @@ async function checkSidecarEnv(base, env, stateDir = corenelDir()) {
     return { name: "sidecar", status: "fail", detail: `${base}  (env: ${env}) -- ${e instanceof Error ? e.message : String(e)}` };
   }
 }
+function apiCheck(resolved) {
+  const note = apiBaseNote(resolved.source);
+  const detail = note ? `${resolved.base}  (${note}; installed default is ${DEFAULT_API_BASE2})` : resolved.base === DEFAULT_API_BASE2 ? resolved.base : `${resolved.base}  (overridden; default is ${DEFAULT_API_BASE2})`;
+  return { name: "api", status: "ok", detail };
+}
 async function collectChecks(f = fetch, modelId = DEFAULT_MODEL, env) {
-  const base = await apiBase();
+  const resolvedBase = await resolveCliApiBase();
+  const base = resolvedBase.base;
   const checks = [
     { name: "binary", status: "ok", detail: selfPath() },
     { name: "version", status: "ok", detail: `@corenel/cli ${version()}` },
     { name: "node", status: "ok", detail: process.version },
-    {
-      name: "api",
-      status: "ok",
-      detail: base === DEFAULT_API_BASE2 ? base : `${base}  (overridden; default is ${DEFAULT_API_BASE2})`
-    }
+    apiCheck(resolvedBase)
   ];
   try {
     const u = new URL(base);
@@ -25779,7 +25810,7 @@ import { createInterface } from "node:readline";
 import { PermissionService as PermissionService4 } from "@corenel/harness/guardrail/permission-service";
 import { STANDARD_POLICY as STANDARD_POLICY2 } from "@corenel/harness/guardrail/builtins";
 import { approvalsHooks } from "@corenel/harness/approvals";
-import { TermSession, parseSuggestionChoice, suggestionKeys, suggestionLine, suggestionOutcome } from "@corenel/term/session";
+import { TermSession, startupResumeOptions, parseSuggestionChoice, suggestionKeys, suggestionLine, suggestionOutcome } from "@corenel/term/session";
 import { describeToolCall, formatOrd } from "@corenel/term/describe";
 import { buildWritePreview } from "@corenel/term/writePreview";
 import { formatEndingChange } from "@corenel/term/diff";
@@ -25937,10 +25968,10 @@ async function runRepl(deps) {
     }
   });
   if (deps.resume) {
-    await session.resume(deps.resume.id);
+    await session.resume(deps.resume.id, startupResumeOptions(deps.resume));
     const restored = session.getSnapshot();
     if (restored.session) {
-      writeLine(`  resumed ${restored.session.id} - ${restored.committed.length} messages
+      writeLine(`  resumed ${restored.session.id} - ${restored.committed.filter((i) => i.kind !== "note").length} messages
 `);
     }
   }
@@ -26227,6 +26258,44 @@ ${rules(r.workspace)}`);
 import { approvalsHooks as approvalsHooks2 } from "@corenel/harness/approvals";
 import { createSessionPersistence } from "@corenel/term/persist";
 
+// src/resumeModel.ts
+import { estimateFill, COMPACT_AT_FILL } from "@corenel/harness/core/compactHistory";
+import { resolveContextWindow as resolveContextWindow2 } from "@corenel/harness/providers/contextWindow";
+var DEFAULT_MODEL2 = "gpt-4o-mini";
+function resumeModel(flagModel, stored, fallback) {
+  return flagModel || stored || fallback;
+}
+async function storedModelOf(resume, persistence) {
+  if (!resume) return void 0;
+  const loaded = await persistence.load(resume.id);
+  if (!loaded) return void 0;
+  return { id: loaded.id, messages: loaded.messages, ...loaded.model ? { model: loaded.model } : {} };
+}
+async function resolveSessionModel(input) {
+  const { argv, persistence, fallback, isKnownModel } = input;
+  const windowOf = input.contextWindow ?? ((m) => resolveContextWindow2(m).window);
+  const flagModel = hasValueFlag(argv, "model") ? flag(argv, "model", "") || void 0 : void 0;
+  const resume = resumeFlag(argv);
+  let chat;
+  try {
+    chat = await storedModelOf(resume, persistence);
+  } catch {
+    const model = flagModel ?? fallback;
+    return { model, notice: `could not read this chat's model, so it will run on ${model}.` };
+  }
+  const stored = chat?.model;
+  if (flagModel) {
+    if (!chat || !stored || stored === flagModel) return { model: flagModel };
+    const folds = estimateFill(chat.messages, windowOf(flagModel)) >= COMPACT_AT_FILL;
+    const notice = `chat ${chat.id} was on ${stored}; continuing on ${flagModel} (this changes the chat's model)` + (folds ? ", and older history will be folded to fit." : ".");
+    return { model: flagModel, notice };
+  }
+  if (stored && isKnownModel && !isKnownModel(stored)) {
+    return { model: fallback, notice: `this chat used ${stored}, which is not available. It will run on ${fallback}.` };
+  }
+  return { model: resumeModel(void 0, stored, fallback) };
+}
+
 // src/shellTool.ts
 import { spawn as spawn3 } from "node:child_process";
 var MAX_OUTPUT = 3e4;
@@ -27031,8 +27100,8 @@ async function resolveStrategyPrompt(files, id) {
 }
 
 // src/policyResolve.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
+init_tools_node();
+import { readFile as readFile2, stat } from "node:fs/promises";
 import { join as join11 } from "node:path";
 import { stateDirName as stateDirName6 } from "@corenel/protocol";
 import { BUILTIN_POLICIES, STANDARD_POLICY as STANDARD_POLICY3, policyFromYaml } from "@corenel/harness/guardrail";
@@ -27081,25 +27150,55 @@ function validateOrThrow(text, path) {
   }
   return result.policy;
 }
+async function projectPolicyPath(cwd, homeBase) {
+  return join11(corenelDir(homeBase), "policies", `ws-${await workspaceApprovalsId(cwd)}.yaml`);
+}
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (e) {
+    return !(isErrnoException(e) && e.code === "ENOENT");
+  }
+}
 async function resolvePolicy(opts) {
-  const { flag: flag2, cwd } = opts;
+  const { flag: flag2, cwd, homeBase } = opts;
+  const warnings = [];
   if (flag2) {
     if (Object.prototype.hasOwnProperty.call(BUILTIN_POLICIES, flag2)) {
-      return { policy: BUILTIN_POLICIES[flag2], source: { kind: "builtin", name: flag2 } };
+      return { policy: BUILTIN_POLICIES[flag2], source: { kind: "builtin", name: flag2 }, warnings };
     }
     const policy = await loadRequiredPolicyFile(
       flag2,
       `corenel: unknown --policy "${flag2}" -- not a builtin (${Object.keys(BUILTIN_POLICIES).join(", ")}) and no file exists at that path.`
     );
-    return { policy, source: { kind: "file", path: flag2 } };
+    return { policy, source: { kind: "file", path: flag2 }, warnings };
+  }
+  const stateDir = corenelDir(homeBase);
+  const projectPath = await projectPolicyPath(cwd, homeBase);
+  const userPath = join11(stateDir, "policy.yaml");
+  if (await insideAnyRoot([cwd], stateDir) !== null) {
+    const present2 = [];
+    if (await fileExists(projectPath)) present2.push(projectPath);
+    if (await fileExists(userPath)) present2.push(userPath);
+    if (present2.length) {
+      throw new PolicyResolutionError(
+        `corenel: not loading ${present2.join(" or ")}: ${stateDir} is inside this folder (${cwd}), where the agent's file tools could have written it. Start corenel from a folder that does not contain it, or pass --policy <name|path> explicitly.`
+      );
+    }
+    return { policy: STANDARD_POLICY3, source: { kind: "default" }, warnings };
+  }
+  const workspacePath = join11(cwd, stateDirName6(), "policy.yaml");
+  if (await fileExists(workspacePath)) {
+    warnings.push(
+      `corenel: ${workspacePath} ignored -- a policy inside the workspace can be written by the agent or arrive in a cloned repo. To use it for this folder, move it to ${projectPath}, or pass --policy ${workspacePath} explicitly.`
+    );
   }
-  const projectPath = join11(cwd, stateDirName6(), "policy.yaml");
   const project = await loadDiscoveredPolicyFile(projectPath);
-  if (project) return { policy: project, source: { kind: "project", path: projectPath } };
-  const userPath = join11(homedir3(), stateDirName6(), "policy.yaml");
+  if (project) return { policy: project, source: { kind: "project", path: projectPath }, warnings };
   const user = await loadDiscoveredPolicyFile(userPath);
-  if (user) return { policy: user, source: { kind: "user", path: userPath } };
-  return { policy: STANDARD_POLICY3, source: { kind: "default" } };
+  if (user) return { policy: user, source: { kind: "user", path: userPath }, warnings };
+  return { policy: STANDARD_POLICY3, source: { kind: "default" }, warnings };
 }
 
 // ../mcp/src/httpClient.ts
@@ -27572,7 +27671,7 @@ function isExpired(cred, nowMs) {
 }
 
 // ../mcp/src/auth.ts
-import { DEFAULT_API_BASE as DEFAULT_API_BASE3 } from "@corenel/protocol";
+import { DEFAULT_API_BASE as DEFAULT_API_BASE4 } from "@corenel/protocol";
 function safeOrigin(url) {
   try {
     return new URL(url).origin;
@@ -27580,24 +27679,30 @@ function safeOrigin(url) {
     return "its URL";
   }
 }
-function isCorenelRelayUrl(url, bases) {
+function isCorenelRelayUrl(url, bases, devApiBases = []) {
   let u;
   try {
     u = new URL(url);
   } catch {
     return false;
   }
-  if (u.protocol !== "https:") return false;
   if (!/\/mcp\/hosted\/[^/]+\/?$/.test(u.pathname)) return false;
-  return bases.some((b) => {
+  const sameOrigin = (b) => {
     try {
       return new URL(b).origin === u.origin;
     } catch {
       return false;
     }
-  });
+  };
+  if (u.protocol === "https:") return [...bases, ...devApiBases].some(sameOrigin);
+  if (u.protocol === "http:" && isLoopbackHost(u.hostname)) return devApiBases.some(sameOrigin);
+  return false;
+}
+function isLoopbackHost(hostname2) {
+  const h = hostname2.replace(/^\[|\]$/g, "").toLowerCase();
+  return h === "localhost" || h === "127.0.0.1" || h === "::1";
 }
-function authProviderFor(stateDir, server, fetchImpl = fetch, accountToken = async () => null, relayBases = async () => []) {
+function authProviderFor(stateDir, server, fetchImpl = fetch, accountToken = async () => null, relayBases = async () => [], devApiBases = []) {
   async function doRefresh(cred) {
     if (!cred.refreshToken) {
       throw new Error(`"${server.name}" has no refresh token on file -- run: corenel mcp login ${server.name}`);
@@ -27610,7 +27715,7 @@ function authProviderFor(stateDir, server, fetchImpl = fetch, accountToken = asy
   return {
     async headers() {
       const cred = await readMcpCredential(stateDir, server.name);
-      if (server.hosted && !isCorenelRelayUrl(server.url, [DEFAULT_API_BASE3, ...await relayBases()])) {
+      if (server.hosted && !isCorenelRelayUrl(server.url, [DEFAULT_API_BASE4, ...await relayBases()], devApiBases)) {
         throw new Error(`"${server.name}" is marked hosted but ${safeOrigin(server.url)} is not a Corenel relay; refusing to send the account token there.`);
       }
       if (!cred && !server.hosted) {
@@ -27661,10 +27766,17 @@ async function accountTokenFor(stateDir) {
     return null;
   }
 }
+function mcpClientFactory(opts = {}) {
+  const devApiBases = [...opts.devApiBases ?? []];
+  return (stateDir, server) => buildClient(stateDir, server, devApiBases);
+}
 function defaultClientFactory(stateDir, server) {
+  return buildClient(stateDir, server, []);
+}
+function buildClient(stateDir, server, devApiBases) {
   return new McpHttpClient(
     server,
-    authProviderFor(stateDir, server, timedFetch(AUTH_REQUEST_TIMEOUT_MS), () => accountTokenFor(stateDir), () => relayBasesFor(stateDir))
+    authProviderFor(stateDir, server, timedFetch(AUTH_REQUEST_TIMEOUT_MS), () => accountTokenFor(stateDir), () => relayBasesFor(stateDir), devApiBases)
   );
 }
 async function relayBasesFor(stateDir) {
@@ -28002,11 +28114,11 @@ function cacheEntryFor(cache, server, cred) {
 }
 
 // src/mcpRegistry.ts
-async function openCliMcp(stateDir, policy) {
+async function openCliMcp(stateDir, policy, opts = {}) {
   try {
     const servers = await readMcpServers(stateDir);
     if (servers.length === 0) return null;
-    const registry = new McpRegistry(stateDir);
+    const registry = new McpRegistry(stateDir, mcpClientFactory({ devApiBases: opts.devApiBases ?? [] }));
     const cache = await readToolCache(stateDir);
     const usable = {};
     for (const s of servers) {
@@ -28399,8 +28511,18 @@ import { lookup as dnsLookup } from "node:dns/promises";
 import { setOutboundResolver } from "@corenel/harness/tools/urlGuard";
 var EXIT_POLICY_PARK_REFUSED = 3;
 var EXIT_BUDGET_EXCEEDED = 4;
-async function agentSetup(argv) {
-  setGatewayBase2(await apiBase(flag(argv, "base", "")));
+function replSessionId(id) {
+  return id === UNATTACHED_SESSION ? null : id;
+}
+function replCompaction(client, model, contextWindow, files, getSessionId) {
+  return {
+    summarize: makeSummarizer(client, model, { contextWindow }),
+    storage: makeSessionFoldStorage({ getFiles: () => files, root: sessionsRoot(), sessionId: getSessionId })
+  };
+}
+async function agentSetup(argv, chosenModel) {
+  const gatewayBase = await resolveCliApiBase(flag(argv, "base", ""));
+  setGatewayBase2(gatewayBase.base);
   const token = await nodeAuthToken().getToken();
   if (!token) {
     process.stderr.write("corenel: not signed in.\n  Run `corenel login`, or set CORENEL_TOKEN=<token> (a gateway bearer token), then try again.\n");
@@ -28442,19 +28564,22 @@ async function agentSetup(argv) {
   let policy;
   let policySource;
   try {
-    ({ policy, source: policySource } = await resolvePolicy({
+    const resolved = await resolvePolicy({
       ...hasValueFlag(argv, "policy") ? { flag: flag(argv, "policy", "") } : {},
       cwd: process.cwd()
-    }));
+    });
+    ({ policy, source: policySource } = resolved);
+    for (const w of resolved.warnings) process.stderr.write(`${w}
+`);
   } catch (e) {
     sidecarProcs?.disconnect();
     throw e;
   }
-  const mcp = await openCliMcp(configWorkspaceRoot(), policy);
+  const mcp = await openCliMcp(configWorkspaceRoot(), policy, { devApiBases: cliDevRelayBases(gatewayBase) });
   if (mcp) tools.push(...mcp.tools);
   return {
     client: createChatClient2({ getToken: async () => token }),
-    model: flag(argv, "model", "gpt-4o-mini"),
+    model: chosenModel ?? flag(argv, "model", DEFAULT_MODEL2),
     system,
     tools,
     identity: identity2,
@@ -28558,10 +28683,10 @@ async function run(argv) {
          * with a real window buys exactly that awareness without turning on
          * rung-1 offload here (this path builds no recall store).
          *
-         * No `onCheckpoint`: a one-shot run has no session to write one beside.
+         * No fold storage: a one-shot run has no session to write one beside.
          * It still compacts — surviving the wall matters more than recording why. */
-        compression: { mode: "off", contextWindow: resolveContextWindow2(model).window },
-        compaction: { summarize: makeSummarizer(client, model) },
+        compression: { mode: "off", contextWindow: resolveContextWindow3(model).window },
+        compaction: { summarize: makeSummarizer(client, model, { contextWindow: resolveContextWindow3(model).window }) },
         // A spawned sub-agent runs under the SAME gate as the parent turn -- never
         // looser, so it can't be used to route around the default-deny above.
         toolCtx: nodeToolCtx(ac.signal, {
@@ -28599,7 +28724,12 @@ async function run(argv) {
   }
 }
 async function interactive(argv) {
-  const { client, model, tools, identity: identity2, policy, policySource, memory, mcp, disconnect } = await agentSetup(argv);
+  const chosen = await resolveSessionModel({
+    argv,
+    persistence: createSessionPersistence(new NodeFileService(process.cwd())),
+    fallback: DEFAULT_MODEL2
+  });
+  const { client, model, tools, identity: identity2, policy, policySource, memory, mcp, disconnect } = await agentSetup(argv, chosen.model);
   try {
     await runInteractive();
   } finally {
@@ -28614,7 +28744,7 @@ async function interactive(argv) {
     const approvalsContext = { runId: randomUUID(), workspace: basename5(cwd) };
     let modelRates = null;
     let priceTable = /* @__PURE__ */ new Map();
-    const resolvedWindow = resolveContextWindow2(model);
+    const resolvedWindow = resolveContextWindow3(model);
     alog("context window", model, resolvedWindow.window, `(${resolvedWindow.source})`);
     const compression = { mode: "balanced", contextWindow: resolvedWindow.window, strategy: "deferred" };
     const priceBase = await apiBase(flag(argv, "base", ""));
@@ -28682,11 +28812,9 @@ async function interactive(argv) {
     const onSessionId = (id) => {
       currentSessionId = id;
     };
-    const compaction = {
-      summarize: makeSummarizer(client, model),
-      onCheckpoint: (body) => makeCheckpointStore(() => files, sessionsRoot()).append(currentSessionId, body)
-    };
-    const resume = resumeFlag(argv);
+    const compaction = replCompaction(client, model, () => compression.contextWindow, files, () => replSessionId(currentSessionId));
+    const resumeBase = resumeFlag(argv);
+    const resume = resumeBase ? { ...resumeBase, ...chosen.notice ? { notice: chosen.notice } : {} } : void 0;
     if (chooseFace(currentFaceEnv(argv)) === "tui") {
       try {
         const { runTui } = await import("@corenel/term/ink");
@@ -28785,6 +28913,7 @@ async function interactive(argv) {
 }
 async function main() {
   const [cmd, ...rest] = process.argv.slice(2);
+  setSourceRun(isSourceRun(import.meta.url));
   setOutboundResolver(async (h) => (await dnsLookup(h, { all: true, verbatim: true })).map((a) => a.address));
   try {
     setAgentLogging(hasBooleanFlag(process.argv, "debug") || process.env.CORENEL_DEBUG === "1");
@@ -28862,7 +28991,7 @@ Logged in. Token saved to ${authTokenPath()}
         await runLogout();
         break;
       case "doctor": {
-        process.exitCode = await runDoctor(void 0, void 0, flag(rest, "model", "gpt-4o-mini"), resolveDoctorEnv(rest));
+        process.exitCode = await runDoctor(void 0, void 0, flag(rest, "model", DEFAULT_MODEL2), resolveDoctorEnv(rest));
         break;
       }
       case "approvals":
@@ -28935,5 +29064,7 @@ main().catch((e) => {
 export {
   EXIT_BUDGET_EXCEEDED,
   EXIT_POLICY_PARK_REFUSED,
-  buildRunPermission
+  buildRunPermission,
+  replCompaction,
+  replSessionId
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@corenel/cli",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "description": "Corenel CLI — runs the harness in node, in-proc, no transport. The headless proof the kernel is host-agnostic. (corenel run/ask/chat/login + start --sidecar to follow.)",
   "bin": {
@@ -9,11 +9,11 @@
   "dependencies": {
     "openai": "^4.77.0",
     "ws": "^8.18.0",
-    "@corenel/config": "0.6.0",
-    "@corenel/mcp": "0.4.0",
-    "@corenel/protocol": "0.12.0",
-    "@corenel/harness": "0.13.0",
-    "@corenel/term": "0.7.0"
+    "@corenel/config": "0.6.1",
+    "@corenel/harness": "0.14.0",
+    "@corenel/mcp": "0.5.0",
+    "@corenel/protocol": "0.13.0",
+    "@corenel/term": "0.8.0"
   },
   "devDependencies": {
     "esbuild": "^0.21.5",
@@ -22,7 +22,7 @@
     "tsx": "^4.19.2",
     "typescript": "^5.9.3",
     "@corenel/crew": "0.0.0",
-    "@corenel/tools-node": "0.7.0"
+    "@corenel/tools-node": "0.7.1"
   },
   "publishConfig": {
     "access": "public"