@ordewell/core 0.4.3 → 0.4.4

package/dist/index.mjs

@@ -9890,8 +9890,12 @@ var Block = /* @__PURE__ */ ((Block2) => {
   Block2[Block2["IfInteractive"] = 7] = "IfInteractive";
   Block2[Block2["IfHeadlessSession"] = 8] = "IfHeadlessSession";
   Block2[Block2["IfInteractiveVariant"] = 9] = "IfInteractiveVariant";
+  Block2[Block2["IfProjectTrust"] = 10] = "IfProjectTrust";
   return Block2;
 })(Block || {});
+function isInteractive(ctx) {
+  return ctx.interactive ?? !ctx.headless;
+}
 function resolveArgs(manifest, ctx) {
   const args = [];
   const env = {};
@@ -9960,6 +9964,8 @@ function parseBlockOpen(raw) {
       return 8 /* IfHeadlessSession */;
     case "{{if interactiveVariant}}":
       return 9 /* IfInteractiveVariant */;
+    case "{{if projectTrust}}":
+      return 10 /* IfProjectTrust */;
     default:
       return null;
   }
@@ -9981,19 +9987,24 @@ function shouldIncludeBlock(block, ctx) {
     // `--variant` is a headless-only flag: it exists on `opencode run` but not
     // on the interactive TUI, which exits immediately if handed an unknown flag.
     case 6 /* IfVariant */:
-      return !!ctx.thinkingEffort && !!ctx.headless;
+      return !!ctx.thinkingEffort && !isInteractive(ctx);
     // Session-shape blocks: unlike IfHeadless (a permission-flag gate with a
     // plan-mode carve-out), these pick the CLI invocation shape — e.g.
     // opencode's `run` subcommand vs its interactive TUI — so no mode carve-out.
     case 7 /* IfInteractive */:
-      return !ctx.headless;
+      return isInteractive(ctx);
     case 8 /* IfHeadlessSession */:
-      return !!ctx.headless;
+      return !isInteractive(ctx);
     // Interactive counterpart of IfVariant, for runners whose TUI has no
     // variant flag and must receive the variant via env config instead.
     // Requires a provider-prefixed model: the config pins variant per model.
     case 9 /* IfInteractiveVariant */:
-      return !!ctx.thinkingEffort && !!ctx.model?.includes("/") && !ctx.headless;
+      return !!ctx.thinkingEffort && !!ctx.model?.includes("/") && isInteractive(ctx);
+    // Guards the flag/value pair that pre-trusts the workspace directory. The
+    // condition, not the token, is what keeps a bare `-c` out of the args when
+    // there is no cwd to name.
+    case 10 /* IfProjectTrust */:
+      return isInteractive(ctx) && !!ctx.cwd;
     default:
       return true;
   }
@@ -10014,6 +10025,10 @@ function resolveToken(token, manifest, ctx) {
   if (token === "{{model}}") return ctx.model || "";
   if (token === "{{thinkingEffort}}") return ctx.thinkingEffort || "";
   if (token === "{{mode}}") return ctx.mode || "build";
+  if (token === "{{projectTrust}}") {
+    if (!ctx.cwd) return "";
+    return `projects.${JSON.stringify(ctx.cwd)}.trust_level="trusted"`;
+  }
   if (token === "{{feature:thinking}}") {
     return manifest.features.thinkingFlag || "";
   }
@@ -10100,7 +10115,9 @@ function buildRunnerInvocation(opts) {
     thinkingEffort: opts.thinkingEffort,
     modelVariants: opts.modelVariants,
     mode: opts.mode ?? "build",
-    headless: opts.headless
+    headless: opts.headless,
+    interactive: opts.interactive,
+    cwd: opts.cwd
   });
 }
 
@@ -10221,8 +10238,14 @@ var HeadlessRunner = class extends AbstractRunner {
   hasScriptCmd;
   resolvePath;
   launchDeps;
-  /** Session shape when the caller names none; the VS Code runner overrides it to interactive. */
-  defaultHeadless = true;
+  /**
+   * Session shape: a piped subprocess is not a terminal, so runners get their
+   * non-interactive subcommand. The VS Code runner owns a pseudoterminal and
+   * overrides this to true. Autonomy is a separate axis (see `ResolveContext`)
+   * and stays on either way — no surface has a human answering permission
+   * prompts on the orchestrator's behalf.
+   */
+  defaultInteractive = false;
   constructor(deps = {}) {
     super();
     this.spawnImpl = deps.spawnImpl ?? nodeSpawn2;
@@ -10235,7 +10258,7 @@ var HeadlessRunner = class extends AbstractRunner {
   }
   /** Everything up to, but not including, spawning — so a surface that owns its own child reaches the same decisions. */
   async prepareLaunch(opts) {
-    const headless = opts.headless ?? this.defaultHeadless;
+    const interactive = this.defaultInteractive;
     const invocation = buildRunnerInvocation({
       runner: opts.runner,
       prompt: opts.prompt,
@@ -10243,11 +10266,13 @@ var HeadlessRunner = class extends AbstractRunner {
       thinkingEffort: opts.thinkingEffort,
       modelVariants: opts.modelVariants,
       mode: opts.mode,
-      headless,
+      headless: opts.headless ?? true,
+      interactive,
+      cwd: opts.cwd,
       registry: opts.registry
     });
     const manifest = opts.registry?.get(opts.runner)?.manifest;
-    const pty = (manifest?.runner.requiresTty === true || !headless) && this.hasScriptCmd();
+    const pty = (manifest?.runner.requiresTty === true || interactive) && this.hasScriptCmd();
     const resolvedPath = await this.resolvePath();
     const { command, args } = pty ? wrapWithPty(invocation.command, invocation.args) : { command: invocation.command, args: invocation.args };
     return {
@@ -10491,7 +10516,14 @@ var TmuxRunner = class extends AbstractRunner {
       thinkingEffort: opts.thinkingEffort,
       modelVariants: opts.modelVariants,
       mode: opts.mode,
+      // A tmux window is a real TTY the user can attach to (ADR-0007), so the
+      // runner's own TUI is the point — `interactive`. It is still an
+      // unattended run, so autonomy stays on: the two are separate axes, and
+      // conflating them is what made Codex tasks stream `codex exec` output
+      // into a window that was supposed to show its TUI.
       headless: opts.headless ?? true,
+      interactive: true,
+      cwd: opts.cwd,
       registry: opts.registry
     });
     await this.ensureSession();
@@ -10729,18 +10761,33 @@ var CODEX_MANIFEST = {
   version: "1.0.0",
   runner: {
     command: "codex",
-    // Headless surfaces (CLI/web) use the non-interactive `exec` subcommand
-    // (`--skip-git-repo-check`: task workspaces aren't always git repos, and
-    // exec hard-fails outside one by default); interactive surfaces (VS Code
-    // terminal) launch the TUI with the prompt as its positional argument.
-    // Reasoning effort has no dedicated flag — it travels as a `-c` config
-    // override (see {{feature:reasoningEffortConfig}}). Both `exec` and the
-    // TUI accept `-m`, `-c`, and `--sandbox`.
+    // Headless surfaces (a piped subprocess) use the non-interactive `exec`
+    // subcommand (`--skip-git-repo-check`: task workspaces aren't always git
+    // repos, and exec hard-fails outside one by default); interactive surfaces
+    // (a tmux window, the VS Code terminal) launch the TUI with the prompt as
+    // its positional argument. Reasoning effort has no dedicated flag — it
+    // travels as a `-c` config override (see {{feature:reasoningEffortConfig}}).
+    // Both `exec` and the TUI accept `-m`, `-c`, and `--sandbox`.
+    //
+    // The two interactive-only entries restore what `exec` gives implicitly and
+    // the TUI does not: `exec` is non-interactive, so it can neither ask for
+    // command approval nor ask whether the directory is trusted. The TUI asks
+    // for both by default, and an orchestrated task has nobody to answer —
+    // without these it stalls on a menu instead of working. `-a` does not exist
+    // on `exec`, hence the shape gate rather than a `{{if headless}}` one.
     argsTemplate: [
       "{{if headlessSession}}",
       "exec",
       "--skip-git-repo-check",
       "{{/if}}",
+      "{{if interactive}}",
+      "-a",
+      "never",
+      "{{/if}}",
+      "{{if projectTrust}}",
+      "-c",
+      "{{projectTrust}}",
+      "{{/if}}",
       "{{if model}}",
       "-m",
       "{{model}}",
@@ -10760,9 +10807,9 @@ var CODEX_MANIFEST = {
     planMode: true,
     planModeFlag: "--sandbox",
     permissionModeValues: {
-      // Map mode IDs to --sandbox CLI values. `codex exec` is non-interactive
-      // and has no approval flag, so the sandbox axis is the whole permission
-      // story for headless runs.
+      // Map mode IDs to --sandbox CLI values. Approvals are off on both shapes
+      // (implicitly under `exec`, via `-a never` in the TUI), so the sandbox
+      // axis is the whole permission story for a Codex task.
       "agent": "workspace-write",
       "plan": "read-only",
       "fullAccess": "danger-full-access",