nawabari 0.3.0 → 0.5.0

package/dist/cli.js

@@ -6,6 +6,7 @@ import { EVIDENCE_MAX_DIFF_BYTES, EVIDENCE_MAX_DIFF_HUNKS, EVIDENCE_MAX_DIFF_PAT
 import { createLocalSessionBackend } from "./domain/session-backend.js";
 import { defaultCliIO, renderFailure, renderSuccess } from "./presentation.js";
 import { MACHINE_CONTRACT_ID, MACHINE_CONTRACT_SCHEMA_VERSION, machineContract } from "./contract.js";
+import { resolveSandboxExecutionRequest, runSandboxedCommand, } from "./domain/sandbox.js";
 const CLI_NAME = "nawabari";
 const packageMetadata = createRequire(import.meta.url)("../package.json");
 const VERSION = packageMetadata.version;
@@ -25,14 +26,18 @@ const HELP_COMMANDS = [
                 value: "<name>",
                 default: "nawabari/session/<session_id>",
             }),
-            option("--worktree", "Managed worktree path; omitted uses the resolved repository-local root", {
+            option("--worktree", "Exact managed worktree path override; mutually exclusive with --worktree-root", {
                 value: "<path>",
                 default: "<managed_worktree_root>/<repository>-<session_id>",
             }),
+            option("--worktree-root", "Managed root to place the worktree under; Nawabari derives the final path. Mutually exclusive with --worktree", { value: "<path>", default: "resolved repository-local root" }),
             option("--base", "Commit-resolving base ref for the new worktree", { value: "<ref>", default: "HEAD" }),
             option("--label", "Optional display label; never used as an identity", { value: "<text>", default: "omitted" }),
         ],
-        notes: ["All create options are optional. Use status --json to discover managed_worktree_root."],
+        notes: [
+            "All create options are optional. Use status --json to discover managed_worktree_root.",
+            "--worktree and --worktree-root cannot be combined.",
+        ],
     },
     {
         name: "session id",
@@ -46,6 +51,30 @@ const HELP_COMMANDS = [
         usage: `${CLI_NAME} session show [--session <id>]`,
         options: [option("--session", "Select a session instead of the current worktree owner", { value: "<id>" })],
     },
+    {
+        name: "session inspect",
+        summary: "Report side-effect-free close/cleanup readiness for a session",
+        usage: `${CLI_NAME} session inspect [--session <id>] [--integrated-revision <rev>]`,
+        options: [
+            option("--session", "Select a session instead of the current worktree owner", { value: "<id>" }),
+            option("--integrated-revision", "Externally evidenced revision to test for non-ancestry (squash/rebase) integration; independently re-verified via exact Git tree-object equivalence, never trusted blindly", { value: "<rev>" }),
+        ],
+        notes: [
+            "Read-only: never mutates session, claim, Git, worktree, branch, or registry state. Repeated calls are idempotent.",
+            "Derived from the same authoritative close/cleanup Git evidence as session close; does not duplicate or diverge from that logic.",
+            "Nawabari never queries GitHub or any remote provider; --integrated-revision only names a local revision for Nawabari to independently verify.",
+        ],
+    },
+    {
+        name: "session run",
+        summary: "Run one command inside the protected session sandbox",
+        usage: `${CLI_NAME} session run [--session <id>] -- <command> [args...]`,
+        options: [option("--session", "Select the active owned session", { value: "<id>" })],
+        notes: [
+            "The -- terminator is mandatory. The command is passed as argv without a shell, and protected execution is fail-closed.",
+            "session exec is an alias.",
+        ],
+    },
     {
         name: "session list",
         summary: "List bounded repository session records",
@@ -69,14 +98,25 @@ const HELP_COMMANDS = [
     },
     {
         name: "session update",
-        summary: "Replace a session's resource claims",
-        usage: `${CLI_NAME} session update --resource <path-or-glob> --mode <read|write|exclusive-write> [--session <id>]`,
+        summary: "Atomically replace a session's complete resource claim set",
+        usage: `${CLI_NAME} session update --resource <path-or-glob> --mode <read|write|exclusive-write> [--resource <path-or-glob> --mode <read|write|exclusive-write> ...] [--session <id>]`,
         options: [
-            option("--resource", "Repository-relative resource", { value: "<path-or-glob>", required: true }),
-            option("--mode", "Granted claim mode", { value: "<read|write|exclusive-write>", required: true }),
+            option("--resource", "Repository-relative resource; repeatable, each paired with the --mode immediately after it", {
+                value: "<path-or-glob>",
+                required: true,
+            }),
+            option("--mode", "Mode for the --resource immediately before it; repeatable", {
+                value: "<read|write|exclusive-write>",
+                required: true,
+            }),
             option("--session", "Target active session; omitted resolves the current owner", { value: "<id>" }),
             option("--repository", "Expected repository identity", { value: "<id>" }),
         ],
+        notes: [
+            "The desired claim set fully replaces the session's current claims in one updateClaims() transaction; " +
+                "on any invalid or conflicting claim the prior set is left unchanged.",
+            "Each --resource must be immediately followed by its own --mode; pairing is positional adjacency, not flag order.",
+        ],
     },
     {
         name: "session claims",
@@ -101,9 +141,25 @@ const HELP_COMMANDS = [
     },
     {
         name: "resource update",
-        summary: "Replace a session's resource claims (alias)",
-        usage: `${CLI_NAME} resource update --resource <path-or-glob> --mode <read|write|exclusive-write>`,
-        options: [],
+        summary: "Atomically replace a session's complete resource claim set (alias)",
+        usage: `${CLI_NAME} resource update --resource <path-or-glob> --mode <read|write|exclusive-write> [--resource <path-or-glob> --mode <read|write|exclusive-write> ...] [--session <id>]`,
+        options: [
+            option("--resource", "Repository-relative resource; repeatable, each paired with the --mode immediately after it", {
+                value: "<path-or-glob>",
+                required: true,
+            }),
+            option("--mode", "Mode for the --resource immediately before it; repeatable", {
+                value: "<read|write|exclusive-write>",
+                required: true,
+            }),
+            option("--session", "Target active session; omitted resolves the current owner", { value: "<id>" }),
+            option("--repository", "Expected repository identity", { value: "<id>" }),
+        ],
+        notes: [
+            "The desired claim set fully replaces the session's current claims in one updateClaims() transaction; " +
+                "on any invalid or conflicting claim the prior set is left unchanged.",
+            "Each --resource must be immediately followed by its own --mode; pairing is positional adjacency, not flag order.",
+        ],
     },
     {
         name: "resource list",
@@ -123,8 +179,15 @@ const HELP_COMMANDS = [
     {
         name: "session close",
         summary: "Close the current or selected session",
-        usage: `${CLI_NAME} session close [--session <id>]`,
-        options: [option("--session", "Select a session instead of the current worktree owner", { value: "<id>" })],
+        usage: `${CLI_NAME} session close [--session <id>] [--integrated-revision <rev>]`,
+        options: [
+            option("--session", "Select a session instead of the current worktree owner", { value: "<id>" }),
+            option("--integrated-revision", "Externally evidenced revision proving non-ancestry (squash/rebase) integration; independently re-verified via exact Git tree-object equivalence, never trusted blindly", { value: "<rev>" }),
+        ],
+        notes: [
+            "Ordinary ancestry-based close remains the cheap/default path and requires no flags.",
+            "Nawabari never queries GitHub or any remote provider; --integrated-revision only names a local revision for Nawabari to independently verify.",
+        ],
     },
     {
         name: "authorize",
@@ -246,7 +309,9 @@ function helpSpecFor(commandArguments) {
         return ROOT_HELP_SPEC;
     let key = commandArguments[0] === "resource"
         ? `resource ${commandArguments[1] ?? "list"}`
-        : commandArguments.slice(0, 2).join(" ");
+        : commandArguments[0] === "session" && commandArguments[1] === "exec"
+            ? "session run"
+            : commandArguments.slice(0, 2).join(" ");
     if (key === "resource claims")
         key = "resource list";
     const direct = HELP_COMMANDS.find((spec) => spec.name === key);
@@ -348,7 +413,17 @@ function parseGlobalArguments(argv) {
     let help = false;
     let version = false;
     const commandArguments = [];
+    let passthrough = false;
     for (const argument of argv) {
+        if (passthrough) {
+            commandArguments.push(argument);
+            continue;
+        }
+        if (argument === "--") {
+            passthrough = true;
+            commandArguments.push(argument);
+            continue;
+        }
         if (argument === "--json") {
             json = true;
         }
@@ -381,6 +456,7 @@ function parseOptions(arguments_, allowed) {
         session_id: null,
         branch: null,
         worktree: null,
+        worktree_root: null,
         base: null,
         label: null,
         resource: null,
@@ -406,6 +482,7 @@ function parseOptions(arguments_, allowed) {
         patch: false,
         max_bytes: null,
         max_hunks: null,
+        integrated_revision: null,
     };
     let dryRun = false;
     for (let index = 0; index < arguments_.length; index += 1) {
@@ -451,6 +528,8 @@ function parseOptions(arguments_, allowed) {
             options.branch = value;
         else if (name === "--worktree")
             options.worktree = value;
+        else if (name === "--worktree-root")
+            options.worktree_root = value;
         else if (name === "--base")
             options.base = value;
         else if (name === "--label")
@@ -489,6 +568,8 @@ function parseOptions(arguments_, allowed) {
             options.max_bytes = value;
         else if (name === "--max-hunks")
             options.max_hunks = value;
+        else if (name === "--integrated-revision")
+            options.integrated_revision = value;
     }
     if (options.apply && dryRun) {
         return failure(usageError("INVALID_ARGUMENT", "--apply and --dry-run cannot be used together."));
@@ -498,6 +579,83 @@ function parseOptions(arguments_, allowed) {
 function noOptions(arguments_) {
     return parseOptions(arguments_, new Set());
 }
+/**
+ * `update` accepts a complete desired claim set as repeated
+ * `--resource <path> --mode <mode>` pairs. Pairing is by strict local
+ * adjacency (each `--resource` must be immediately followed by its own
+ * `--mode`, with no other option able to intervene) rather than by
+ * parallel-array position, so argv order can never associate a resource
+ * with the wrong mode.
+ */
+function parseClaimReplacementPairs(arguments_) {
+    let sessionId = null;
+    let repository = null;
+    const pairs = [];
+    let pendingResource = null;
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const { name, inlineValue } = optionParts(arguments_[index]);
+        if (name !== "--session" && name !== "--repository" && name !== "--resource" && name !== "--mode") {
+            return failure(usageError("INVALID_ARGUMENT", `Unknown option: ${name}.`, { option: name }));
+        }
+        if (pendingResource !== null && name !== "--mode") {
+            return failure(usageError("INVALID_ARGUMENT", `${name} cannot appear between --resource and its --mode; only --mode is permitted immediately after --resource.`, { option: name }));
+        }
+        const value = inlineValue ?? arguments_[index + 1];
+        if (value === undefined || value === "" || (inlineValue === null && value.startsWith("-"))) {
+            return failure(usageError("MISSING_ARGUMENT", `${name} requires a value.`, { option: name }));
+        }
+        if (inlineValue === null)
+            index += 1;
+        if (name === "--session")
+            sessionId = value;
+        else if (name === "--repository")
+            repository = value;
+        else if (name === "--resource")
+            pendingResource = value;
+        else {
+            if (pendingResource === null) {
+                return failure(usageError("INVALID_ARGUMENT", "--mode must be immediately preceded by its own --resource.", {
+                    option: "--mode",
+                }));
+            }
+            pairs.push({ resource: pendingResource, mode: value });
+            pendingResource = null;
+        }
+    }
+    if (pendingResource !== null) {
+        return failure(usageError("MISSING_ARGUMENT", "--resource must be immediately followed by --mode.", { option: "--mode" }));
+    }
+    if (pairs.length === 0) {
+        return failure(usageError("MISSING_ARGUMENT", "--resource requires a value.", { option: "--resource" }));
+    }
+    return { ok: true, value: { session_id: sessionId, repository, pairs } };
+}
+/**
+ * `claim` accepts exactly one `--resource`/`--mode` pair. Reuses the same
+ * strict-adjacency scan as `update` so a second `--resource`/`--mode` (in
+ * any order) is rejected outright instead of silently overwriting the
+ * first pair (last-wins).
+ */
+function parseSingleClaimPair(arguments_) {
+    const parsed = parseClaimReplacementPairs(arguments_);
+    if (!parsed.ok)
+        return parsed;
+    if (parsed.value.pairs.length > 1) {
+        return failure(usageError("INVALID_ARGUMENT", "claim accepts exactly one --resource/--mode pair.", {
+            pair_count: parsed.value.pairs.length,
+        }));
+    }
+    const [pair] = parsed.value.pairs;
+    return {
+        ok: true,
+        value: {
+            session_id: parsed.value.session_id,
+            repository: parsed.value.repository,
+            resource: pair.resource,
+            mode: pair.mode,
+        },
+    };
+}
 function sessionListingOptions(parsed) {
     const parseInteger = (option, value) => {
         if (value === null)
@@ -557,25 +715,33 @@ async function executeCommand(commandArguments, dependencies) {
         if (subcommand === undefined) {
             return failure(usageError("MISSING_ARGUMENT", "session requires a subcommand."));
         }
-        if (subcommand === "claim" || subcommand === "update") {
-            const parsed = parseOptions(rest, new Set(["--session", "--resource", "--mode", "--repository"]));
+        if (subcommand === "claim") {
+            const parsed = parseSingleClaimPair(rest);
             if (!parsed.ok)
                 return parsed;
-            if (parsed.value.resource === null) {
-                return failure(usageError("MISSING_ARGUMENT", "--resource requires a value.", { option: "--resource" }));
-            }
-            if (parsed.value.mode === null) {
-                return failure(usageError("MISSING_ARGUMENT", "--mode requires a value.", { option: "--mode" }));
-            }
-            const options = {
+            if (dependencies.backend.claimResources === undefined)
+                return claimCapabilityUnavailable(subcommand);
+            const result = await dependencies.backend.claimResources(context, {
                 session_id: parsed.value.session_id,
                 repository: parsed.value.repository,
                 claims: [{ resource: parsed.value.resource, mode: parsed.value.mode }],
-            };
-            const operation = subcommand === "claim" ? dependencies.backend.claimResources : dependencies.backend.updateClaims;
-            if (operation === undefined)
+            });
+            return result.ok ? { ok: true, value: result.value } : result;
+        }
+        if (subcommand === "update") {
+            const parsed = parseClaimReplacementPairs(rest);
+            if (!parsed.ok)
+                return parsed;
+            if (dependencies.backend.updateClaims === undefined)
                 return claimCapabilityUnavailable(subcommand);
-            const result = await operation.call(dependencies.backend, context, options);
+            const result = await dependencies.backend.updateClaims(context, {
+                session_id: parsed.value.session_id,
+                repository: parsed.value.repository,
+                claims: parsed.value.pairs.map((pair) => ({
+                    resource: pair.resource,
+                    mode: pair.mode,
+                })),
+            });
             return result.ok ? { ok: true, value: result.value } : result;
         }
         if (subcommand === "claims") {
@@ -600,18 +766,57 @@ async function executeCommand(commandArguments, dependencies) {
             return result.ok ? { ok: true, value: result.value } : result;
         }
         if (subcommand === "create") {
-            const parsed = parseOptions(rest, new Set(["--branch", "--worktree", "--base", "--label"]));
+            const parsed = parseOptions(rest, new Set(["--branch", "--worktree", "--worktree-root", "--base", "--label"]));
             if (!parsed.ok)
                 return parsed;
+            if (parsed.value.worktree !== null && parsed.value.worktree_root !== null) {
+                return failure(usageError("INVALID_ARGUMENT", "--worktree and --worktree-root cannot be used together."));
+            }
             const options = {
                 branch: parsed.value.branch,
                 worktree: parsed.value.worktree,
+                worktree_root: parsed.value.worktree_root,
                 base: parsed.value.base,
                 label: parsed.value.label,
             };
             const result = await dependencies.backend.createSession(context, options);
             return result.ok ? { ok: true, value: result.value } : result;
         }
+        if (subcommand === "run" || subcommand === "exec") {
+            const delimiter = rest.indexOf("--");
+            if (delimiter === -1) {
+                return failure(usageError("MISSING_ARGUMENT", "session run requires a -- terminator before the command."));
+            }
+            const parsed = parseOptions(rest.slice(0, delimiter), new Set(["--session"]));
+            if (!parsed.ok)
+                return parsed;
+            const command = rest[delimiter + 1];
+            if (command === undefined || command.length === 0) {
+                return failure(usageError("MISSING_ARGUMENT", "session run requires a command after --."));
+            }
+            const request = await resolveSandboxExecutionRequest(dependencies.backend, context, { session_id: parsed.value.session_id, enforce: true }, dependencies.sandboxProbe, dependencies.sandboxRuntimeLayout);
+            if (!request.ok)
+                return request;
+            const runner = dependencies.sandboxRunner ?? runSandboxedCommand;
+            const result = await runner(request.value, {
+                command,
+                args: rest.slice(delimiter + 2),
+            });
+            return result.ok ? { ok: true, value: result.value } : result;
+        }
+        if (subcommand === "inspect") {
+            const parsed = parseOptions(rest, new Set(["--session", "--integrated-revision"]));
+            if (!parsed.ok)
+                return parsed;
+            if (dependencies.backend.sessionDiagnostic === undefined)
+                return sessionDiagnosticCapabilityUnavailable();
+            const options = {
+                session_id: parsed.value.session_id,
+                integrated_revision: parsed.value.integrated_revision,
+            };
+            const result = await dependencies.backend.sessionDiagnostic(context, options);
+            return result.ok ? { ok: true, value: result.value } : result;
+        }
         if (subcommand === "id" || subcommand === "show" || subcommand === "close") {
             if (subcommand === "id") {
                 const parsed = noOptions(rest);
@@ -622,11 +827,14 @@ async function executeCommand(commandArguments, dependencies) {
                     return selected;
                 return { ok: true, value: { session_id: selected.value.session_id } };
             }
-            const parsed = parseOptions(rest, new Set(["--session"]));
+            const parsed = parseOptions(rest, new Set(subcommand === "close" ? ["--session", "--integrated-revision"] : ["--session"]));
             if (!parsed.ok)
                 return parsed;
             if (subcommand === "close") {
-                const closeOptions = { session_id: parsed.value.session_id };
+                const closeOptions = {
+                    session_id: parsed.value.session_id,
+                    integrated_revision: parsed.value.integrated_revision,
+                };
                 const selected = await dependencies.backend.closeSession(context, closeOptions);
                 return selected.ok ? { ok: true, value: selected.value } : selected;
             }
@@ -647,23 +855,35 @@ async function executeCommand(commandArguments, dependencies) {
     }
     if (command === "resource") {
         const resourceSubcommand = subcommand ?? "list";
-        if (resourceSubcommand === "claim" || resourceSubcommand === "update") {
-            const parsed = parseOptions(rest, new Set(["--session", "--resource", "--mode", "--repository"]));
+        if (resourceSubcommand === "claim") {
+            const parsed = parseSingleClaimPair(rest);
             if (!parsed.ok)
                 return parsed;
-            if (parsed.value.resource === null || parsed.value.mode === null) {
-                return failure(usageError("MISSING_ARGUMENT", "resource claim requires --resource and --mode."));
-            }
-            const operation = resourceSubcommand === "claim" ? dependencies.backend.claimResources : dependencies.backend.updateClaims;
-            if (operation === undefined)
+            if (dependencies.backend.claimResources === undefined)
                 return claimCapabilityUnavailable(resourceSubcommand);
-            const result = await operation.call(dependencies.backend, context, {
+            const result = await dependencies.backend.claimResources(context, {
                 session_id: parsed.value.session_id,
                 repository: parsed.value.repository,
                 claims: [{ resource: parsed.value.resource, mode: parsed.value.mode }],
             });
             return result.ok ? { ok: true, value: result.value } : result;
         }
+        if (resourceSubcommand === "update") {
+            const parsed = parseClaimReplacementPairs(rest);
+            if (!parsed.ok)
+                return parsed;
+            if (dependencies.backend.updateClaims === undefined)
+                return claimCapabilityUnavailable(resourceSubcommand);
+            const result = await dependencies.backend.updateClaims(context, {
+                session_id: parsed.value.session_id,
+                repository: parsed.value.repository,
+                claims: parsed.value.pairs.map((pair) => ({
+                    resource: pair.resource,
+                    mode: pair.mode,
+                })),
+            });
+            return result.ok ? { ok: true, value: result.value } : result;
+        }
         if (resourceSubcommand === "list" || resourceSubcommand === "claims") {
             const parsed = parseOptions(rest, new Set(["--session"]));
             if (!parsed.ok)
@@ -926,6 +1146,11 @@ function checkpointCapabilityUnavailable() {
         operation: "checkpoint",
     }));
 }
+function sessionDiagnosticCapabilityUnavailable() {
+    return failure(new DomainError("BACKEND_UNAVAILABLE", "Session diagnostic capability is not available.", {
+        operation: "session.inspect",
+    }));
+}
 function repositoryEvidenceCapabilityUnavailable(operation) {
     return failure(new DomainError("BACKEND_UNAVAILABLE", "Repository evidence capability is not available.", { operation }));
 }
@@ -961,9 +1186,62 @@ function emitFailure(mode, command, error, io) {
     io[mode === "json" ? "stdout" : "stderr"](renderFailure(mode, command, error));
     return error.exitCode;
 }
+/** Extract the raw `--session` value a rejected INVALID_SESSION_ID carried, regardless of which command path threw it. */
+function invalidSessionIdQuery(error) {
+    const details = error.details;
+    if (details === null)
+        return null;
+    if (typeof details.sessionId === "string")
+        return details.sessionId;
+    const nested = details.details;
+    if (nested === null || typeof nested !== "object" || Array.isArray(nested))
+        return null;
+    const nestedSessionId = nested.sessionId;
+    return typeof nestedSessionId === "string" ? nestedSessionId : null;
+}
+/**
+ * `--session` stays machine-ID based: an invalid value is never silently
+ * reinterpreted as a label. But when it exactly and unambiguously matches
+ * one active session's label, expose that session's canonical ID as a
+ * bounded, non-authoritative hint instead of forcing a separate `session
+ * list` round trip. Ambiguous or absent matches never guess.
+ */
+async function enrichInvalidSessionIdError(error, backend, context) {
+    if (error.code !== "INVALID_SESSION_ID")
+        return error;
+    const query = invalidSessionIdQuery(error);
+    if (query === null || query.length === 0)
+        return error;
+    const listing = await backend.listSessions(context, { include_closed: false, limit: MAX_SESSION_LIST_LIMIT });
+    if (!listing.ok)
+        return error;
+    const matches = listing.value.sessions.filter((session) => session.state === "active" && session.label === query);
+    const hint = matches.length === 1
+        ? {
+            session_label_query: query,
+            session_label_match: "unique",
+            session_id_hint: matches[0].session_id,
+            safe_actions: ["retry-with-session-id-hint"],
+        }
+        : matches.length > 1
+            ? {
+                session_label_query: query,
+                session_label_match: "ambiguous",
+                session_label_match_count: matches.length,
+                safe_actions: ["disambiguate-session-label", "list-sessions"],
+            }
+            : {
+                session_label_query: query,
+                session_label_match: "none",
+                safe_actions: ["list-sessions"],
+            };
+    return new DomainError(error.code, error.message, { ...error.details, ...hint }, error.exitCode);
+}
 export async function runCli(argv, dependencies = {}) {
     const io = dependencies.io ?? defaultCliIO();
-    const mode = argv.includes("--json") ? "json" : "human";
+    const delimiter = argv.indexOf("--");
+    const globalArguments = delimiter === -1 ? argv : argv.slice(0, delimiter);
+    const mode = globalArguments.includes("--json") ? "json" : "human";
     const parsed = parseGlobalArguments(argv);
     if (!parsed.ok)
         return emitFailure(mode, "cli", parsed.error, io);
@@ -1004,10 +1282,25 @@ export async function runCli(argv, dependencies = {}) {
     const cwd = dependencies.cwd ?? process.cwd();
     try {
         const backend = dependencies.backend ?? createLocalSessionBackend();
-        const result = await executeCommand(parsed.value.commandArguments, { backend, cwd });
-        if (!result.ok)
-            return emitFailure(mode, command, result.error, io);
+        const result = await executeCommand(parsed.value.commandArguments, {
+            backend,
+            cwd,
+            sandboxRunner: dependencies.sandboxRunner,
+            sandboxProbe: dependencies.sandboxProbe,
+            sandboxRuntimeLayout: dependencies.sandboxRuntimeLayout,
+        });
+        if (!result.ok) {
+            const enriched = await enrichInvalidSessionIdError(result.error, backend, sessionContext(cwd));
+            return emitFailure(mode, command, enriched, io);
+        }
         io.stdout(renderSuccess(mode, command, result.value));
+        if ((command === "session run" || command === "session exec") &&
+            typeof result.value.exit_code === "number" &&
+            result.value.exit_code !== 0) {
+            return result.value.exit_code >= 1 && result.value.exit_code <= 255
+                ? result.value.exit_code
+                : EXIT_CODES.rejected;
+        }
         return EXIT_CODES.success;
     }
     catch {