@skrr-ai/cli 0.1.94 → 0.1.96

package/bin/update-session.cjs

@@ -0,0 +1,194 @@
+'use strict';
+
+// This bootstrap uses only Node built-ins: npm may replace the package while
+// the updater runs, so admission and the worker must not depend on its modules.
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { execFileSync } = require('node:child_process');
+// Protocol 1: bakery admission lock, immutable PID/birth/token leases, and
+// process-group mutation ownership. Its wire/locking contract is immutable.
+// Future protocols must coexist with these sessions or require an external
+// package-manager update; selecting a separate lock must never bypass them.
+const COORDINATION_VERSION = 1;
+
+function runtimeDir(packageRoot) {
+  const key = crypto
+    .createHash('sha256')
+    .update(path.resolve(packageRoot))
+    .digest('hex')
+    .slice(0, 24);
+  // Installation leases deliberately ignore SKRR_CONFIG_DIR: two profiles or
+  // config roots still share the same npm installation.
+  return path.join(os.homedir(), '.skrr', 'cli-update-runtime', key);
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const temporary = `${file}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(value), { mode: 0o600, flag: 'wx' });
+    fs.renameSync(temporary, file);
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+}
+
+function processIdentity(pid) {
+  if (process.platform === 'win32') return null;
+  try {
+    return (
+      execFileSync('ps', ['-p', String(pid), '-o', 'lstart='], {
+        timeout: 500,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }).trim() || null
+    );
+  } catch {
+    return null;
+  }
+}
+
+function isAlive(owner) {
+  if (!owner || !Number.isSafeInteger(owner.pid) || owner.pid <= 0) return false;
+  try {
+    process.kill(owner.group && process.platform !== 'win32' ? -owner.pid : owner.pid, 0);
+  } catch (error) {
+    return error.code !== 'ESRCH';
+  }
+  // A recycled PID is not the process that created this lease. If the OS
+  // cannot disclose its identity, remain conservative rather than expiring a
+  // live session on a wall-clock timeout.
+  const identity = owner.identity && processIdentity(owner.pid);
+  return !identity || identity === owner.identity;
+}
+
+function wait(milliseconds) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+
+function acquireLock(directory, timeoutMs = 1000) {
+  // Lamport's bakery algorithm, with one immutable participant filename per
+  // acquisition. Reaping a crashed participant never removes a replacement
+  // owner's lock (the stale-directory removal race of mkdir mutexes).
+  const deadline = Date.now() + timeoutMs;
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  const owner = {
+    pid: process.pid,
+    identity: processIdentity(process.pid),
+    token: crypto.randomUUID(),
+  };
+  const participant = path.join(directory, `${owner.pid}-${owner.token}.json`);
+  const participants = () => {
+    const active = [];
+    for (const file of fs.readdirSync(directory)) {
+      if (!file.endsWith('.json')) continue;
+      const target = path.join(directory, file);
+      const record = readJson(target);
+      if (record && isAlive(record)) active.push(record);
+      else if (record) fs.rmSync(target, { force: true });
+    }
+    return active;
+  };
+  try {
+    writeJson(participant, { ...owner, choosing: true, ticket: 0 });
+    const ticket = Math.max(0, ...participants().map((record) => record.ticket || 0)) + 1;
+    writeJson(participant, { ...owner, choosing: false, ticket });
+    while (true) {
+      const blocked = participants().some(
+        (other) =>
+          other.token !== owner.token &&
+          (other.choosing ||
+            (other.ticket > 0 &&
+              (other.ticket < ticket || (other.ticket === ticket && other.token < owner.token)))),
+      );
+      if (!blocked)
+        return () => {
+          fs.rmSync(participant, { force: true });
+        };
+      if (Date.now() >= deadline)
+        throw Object.assign(new Error('CLI update lock is busy'), { code: 'CLI_UPDATE_BUSY' });
+      wait(25);
+    }
+  } catch (error) {
+    fs.rmSync(participant, { force: true });
+    throw error;
+  }
+}
+
+function liveLeases(directory) {
+  const leaseDir = path.join(directory, 'sessions');
+  fs.mkdirSync(leaseDir, { recursive: true, mode: 0o700 });
+  const live = [];
+  for (const file of fs.readdirSync(leaseDir)) {
+    const target = path.join(leaseDir, file);
+    const lease = readJson(target);
+    if (lease && isAlive(lease)) live.push(lease);
+    else fs.rmSync(target, { force: true });
+  }
+  return live;
+}
+
+function registerSession(packageRoot, timeoutMs = 60000) {
+  const directory = runtimeDir(packageRoot);
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const release = acquireLock(path.join(directory, 'admission.lock'), 1000);
+    try {
+      const mutationFile = path.join(directory, 'mutation.json');
+      const mutation = readJson(mutationFile);
+      if (!mutation || !isAlive(mutation)) {
+        if (mutation) fs.rmSync(mutationFile, { force: true });
+        const token = crypto.randomUUID();
+        const leaseFile = path.join(directory, 'sessions', `${process.pid}-${token}.json`);
+        writeJson(leaseFile, {
+          pid: process.pid,
+          identity: processIdentity(process.pid),
+          token,
+          coordinationVersion: COORDINATION_VERSION,
+        });
+        const cleanup = () => {
+          try {
+            fs.rmSync(leaseFile, { force: true });
+          } catch {
+            /* read-only home */
+          }
+        };
+        process.once('exit', cleanup);
+        return cleanup;
+      }
+    } finally {
+      release();
+    }
+    if (Date.now() >= deadline) {
+      throw Object.assign(
+        new Error(
+          'skrr is being updated by npm. Retry shortly; inspect `skrr update --check` after the update finishes.',
+        ),
+        { code: 'CLI_UPDATE_BUSY' },
+      );
+    }
+    wait(100);
+  }
+}
+
+module.exports = {
+  COORDINATION_VERSION,
+  runtimeDir,
+  readJson,
+  writeJson,
+  processIdentity,
+  isAlive,
+  acquireLock,
+  liveLeases,
+  registerSession,
+};

package/bin/update-worker.cjs

@@ -0,0 +1,208 @@
+'use strict';
+
+// Copied next to update-session.cjs outside the npm package before launch.
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { execFile, spawn } = require('node:child_process');
+const { promisify } = require('node:util');
+const runtime = require('./update-session.cjs');
+const execFileAsync = promisify(execFile);
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const MAX_WAIT_MS = 5 * 60 * 1000;
+const INSTALL_TIMEOUT_MS = 10 * 60 * 1000;
+const MAX_LOG_BYTES = 256 * 1024;
+
+async function run(directory, options = {}) {
+  let releaseWorker;
+  try {
+    releaseWorker = runtime.acquireLock(path.join(directory, 'worker.lock'), 1000);
+  } catch (error) {
+    if (error.code === 'CLI_UPDATE_BUSY') return;
+    throw error;
+  }
+  const stateFile = path.join(directory, 'result.json');
+  let mutation = false;
+  let mutationChild = null;
+  let attempt = runtime.readJson(stateFile);
+  const persist = (changes) => {
+    attempt = { ...attempt, ...changes, updatedAt: Date.now() };
+    runtime.writeJson(stateFile, attempt);
+  };
+  try {
+    if (!attempt || !['queued', 'running'].includes(attempt.status)) return;
+    if (
+      attempt.coordinationVersion != null &&
+      attempt.coordinationVersion !== runtime.COORDINATION_VERSION
+    )
+      throw new Error(
+        'Incompatible CLI update coordination protocol; use the owning package manager',
+      );
+    if (
+      !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(attempt.version) ||
+      !path.isAbsolute(attempt.packageRoot) ||
+      !path.isAbsolute(attempt.npmPath)
+    ) {
+      throw new Error('Invalid persisted CLI update request');
+    }
+    // Serialize admission and the empty-session check. Newly starting CLIs
+    // then wait before loading oclif/package modules until npm has finished.
+    const deadline = Date.now() + (options.maxWaitMs ?? MAX_WAIT_MS);
+    while (true) {
+      const releaseAdmission = runtime.acquireLock(path.join(directory, 'admission.lock'), 1000);
+      try {
+        const previousMutation = runtime.readJson(path.join(directory, 'mutation.json'));
+        if (
+          (!previousMutation || !runtime.isAlive(previousMutation)) &&
+          runtime.liveLeases(directory).length === 0
+        ) {
+          runtime.writeJson(path.join(directory, 'mutation.json'), {
+            pid: process.pid,
+            identity: runtime.processIdentity(process.pid),
+          });
+          mutation = true;
+          break;
+        }
+      } finally {
+        releaseAdmission();
+      }
+      if (Date.now() >= deadline) {
+        persist({
+          status: 'queued',
+          message: 'Waiting for active CLI sessions; the next invocation resumes this request.',
+        });
+        return;
+      }
+      await delay(250);
+    }
+    if (
+      runtime.readJson(path.join(attempt.packageRoot, 'package.json'))?.version === attempt.version
+    ) {
+      persist({
+        status: 'succeeded',
+        finishedAt: Date.now(),
+        installedVersion: attempt.version,
+        message: 'The requested CLI version is already installed.',
+      });
+      return;
+    }
+    const rootResult = await execFileAsync(attempt.npmPath, ['root', '-g'], {
+      timeout: 1500,
+      maxBuffer: 64 * 1024,
+      shell: process.platform === 'win32',
+    });
+    const npmRoot = fs.realpathSync(rootResult.stdout.trim());
+    const expectedPackage = path.join(npmRoot, '@skrr-ai', 'cli');
+    if (fs.realpathSync(expectedPackage) !== fs.realpathSync(attempt.packageRoot)) {
+      throw new Error(
+        'npm global prefix changed; run the update with the package manager that owns this CLI',
+      );
+    }
+    persist({
+      status: 'running',
+      startedAt: Date.now(),
+      workerPid: process.pid,
+      message: 'npm is installing the requested CLI version.',
+    });
+    const logFile = path.join(directory, 'update.log');
+    fs.writeFileSync(logFile, '', { mode: 0o600 });
+    let logBytes = 0;
+    const log = (chunk) => {
+      const bytes = Buffer.from(chunk);
+      if (logBytes >= MAX_LOG_BYTES) return;
+      const bounded = bytes.subarray(0, MAX_LOG_BYTES - logBytes);
+      fs.appendFileSync(logFile, bounded);
+      logBytes += bounded.length;
+    };
+    await new Promise((resolve, reject) => {
+      const requestFile = path.join(directory, `runner-${crypto.randomUUID()}.json`);
+      const token = crypto.randomUUID();
+      runtime.writeJson(requestFile, { token, npmPath: attempt.npmPath, version: attempt.version });
+      const child = spawn(
+        process.execPath,
+        [path.join(__dirname, 'update-npm-runner.cjs'), requestFile],
+        {
+          detached: process.platform !== 'win32',
+          stdio: ['ignore', 'pipe', 'pipe'],
+        },
+      );
+      if (child.pid) {
+        mutationChild = { pid: child.pid, group: process.platform !== 'win32' };
+        runtime.writeJson(path.join(directory, 'mutation.json'), mutationChild);
+        runtime.writeJson(`${requestFile}.go`, { pid: child.pid, token });
+      }
+      child.stdout.on('data', log);
+      child.stderr.on('data', log);
+      let timedOut = false;
+      let forceTimer;
+      const signal = (name) => {
+        try {
+          if (process.platform !== 'win32' && child.pid) process.kill(-child.pid, name);
+          else child.kill(name);
+        } catch {
+          /* already exited */
+        }
+      };
+      const timer = setTimeout(() => {
+        timedOut = true;
+        signal('SIGTERM');
+        forceTimer = setTimeout(() => {
+          signal('SIGKILL');
+        }, 5000);
+      }, options.installTimeoutMs ?? INSTALL_TIMEOUT_MS);
+      child.once('error', (error) => {
+        clearTimeout(timer);
+        clearTimeout(forceTimer);
+        reject(error);
+      });
+      child.once('exit', async (code, exitSignal) => {
+        clearTimeout(timer);
+        if (timedOut) {
+          // npm can exit on TERM while a descendant keeps writing. Complete
+          // KILL escalation for the whole group before releasing admission.
+          signal('SIGKILL');
+          const stopDeadline = Date.now() + 5000;
+          while (mutationChild && runtime.isAlive(mutationChild) && Date.now() < stopDeadline)
+            await delay(50);
+        }
+        clearTimeout(forceTimer);
+        fs.rmSync(requestFile, { force: true });
+        fs.rmSync(`${requestFile}.go`, { force: true });
+        if (timedOut) reject(new Error('npm update exceeded the 10-minute time limit'));
+        else if (code === 0) resolve();
+        else reject(new Error(`npm update failed (${exitSignal || code}); see ${logFile}`));
+      });
+    });
+    const installedVersion = runtime.readJson(
+      path.join(attempt.packageRoot, 'package.json'),
+    )?.version;
+    if (installedVersion !== attempt.version)
+      throw new Error(
+        `npm completed but installed ${installedVersion || 'an unknown version'} instead of ${attempt.version}`,
+      );
+    persist({
+      status: 'succeeded',
+      finishedAt: Date.now(),
+      installedVersion,
+      message: 'The new CLI version is ready for the next invocation.',
+    });
+  } catch (error) {
+    persist({ status: 'failed', finishedAt: Date.now(), message: String(error.message || error) });
+  } finally {
+    // A crashed worker/terminated npm parent can leave a mutating process
+    // group alive. Keep the gate until the group is confirmed gone.
+    if (mutation && (!mutationChild || !runtime.isAlive(mutationChild)))
+      fs.rmSync(path.join(directory, 'mutation.json'), { force: true });
+    releaseWorker();
+  }
+}
+
+if (require.main === module) {
+  const directory = process.argv[2];
+  if (!directory || !path.isAbsolute(directory)) process.exitCode = 1;
+  else
+    run(directory).catch(() => {
+      process.exitCode = 1;
+    });
+}
+module.exports = { run };

package/dist/base-command.js

@@ -52,7 +52,6 @@ const daemonBroker_1 = require("./lib/daemonBroker");
 const daemonBrokerRefusal_1 = require("./lib/daemonBrokerRefusal");
 const refresh_1 = require("./lib/refresh");
 const auth_storage_1 = require("./lib/auth-storage");
-const update_check_1 = require("./lib/update-check");
 const web_url_1 = require("./lib/web-url");
 const edge_error_page_1 = require("./lib/edge-error-page");
 const step_up_1 = require("./lib/step-up");
@@ -541,20 +540,6 @@ class BaseCommand extends core_1.Command {
         }
         (0, node_adapter_1.setAdapterCredentialOverride)(this.resolvedCredential);
         (0, data_provider_1.setHttpAdapter)((0, node_adapter_1.createNodeAdapter)());
-        // Non-blocking "a newer skrr is available" advisory. Decides from a ~4h
-        // on-disk cache (zero added latency) and refreshes in the background.
-        // Writes at most one line to stderr, never stdout, so --json consumers
-        // are unaffected; self-suppresses in bundled/non-TTY/opted-out contexts.
-        // Wrapped so an advisory can never break the command it precedes.
-        try {
-            (0, update_check_1.maybeWarnOutdatedCli)({
-                currentVersion: this.config.version,
-                baseURL: this.cliConfig.baseURL,
-            });
-        }
-        catch {
-            /* advisory is strictly best-effort */
-        }
     }
     /**
      * Read only the two global base flags. A narrow parser — oclif's

package/dist/commands/agent/message/send.d.ts

@@ -85,6 +85,8 @@ export default class AgentMessageSend extends BaseCommand {
         part: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'message-lint': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         destination: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        to: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        subject: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         channel: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'thread-ts': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'thread-root': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/agent/message/send.js

@@ -114,6 +114,11 @@ class AgentMessageSend extends base_command_1.BaseCommand {
             description: 'Destination kind for the canonical intent',
             options: [...message_intent_1.CANONICAL_DESTINATION_KINDS],
         }),
+        to: core_1.Flags.string({
+            description: 'Recipient email address; repeat for up to 5 recipients',
+            multiple: true,
+        }),
+        subject: core_1.Flags.string({ description: 'Plain email subject (agent_email only)' }),
         channel: core_1.Flags.string({
             description: 'Slack channel ID (only meaningful with --destination slack_channel)',
         }),
@@ -178,6 +183,8 @@ class AgentMessageSend extends base_command_1.BaseCommand {
             agentId: flags.agent,
             text: flags.text,
             destinationKind: flags.destination,
+            recipients: flags.to,
+            subject: flags.subject,
             channelId: flags.channel,
             threadTs: flags['thread-ts'],
             threadRootMessageId: flags['thread-root'],
@@ -497,6 +504,9 @@ class AgentMessageSend extends base_command_1.BaseCommand {
                 },
             });
         }
+        if (request.destination.kind === 'agent_email') {
+            this.error('Agent email is available only through an authorized Agent session.');
+        }
         // slack_owner_dm is a Gateway-only destination: it applies workspace-scoped
         // owner routing that no legacy human transport can enact.
         this.failWithCliError({
@@ -538,6 +548,14 @@ function messageSegmentationAdvisory({ destination, text, followingParts, }) {
  * from one explicit semantic idempotency key.
  */
 function buildSequencedRequests(request, followingParts, hasExplicitIdempotencyKey) {
+    if (request.destination.kind === 'agent_email') {
+        if (followingParts.length)
+            throw invalidIntent('Email accepts one plain-text body; --part is not supported.');
+        requireText(request.content.text, 'content.text', 20 * 1024);
+        if (Buffer.byteLength(request.content.text, 'utf8') > 20 * 1024)
+            throw invalidIntent('Email body exceeds 20 KiB.');
+        return [request];
+    }
     const parts = [request.content.text, ...followingParts].map((part) => requireText(part, 'part'));
     if (parts.length === 1)
         return [request];
@@ -586,6 +604,8 @@ const DELIVERY_FAILURE_STATUSES = new Set([
     'dropped',
     'expired',
     'cancelled',
+    'unknown',
+    'refused',
 ]);
 /**
  * Exit codes for a submitted-but-undelivered message.
@@ -723,8 +743,18 @@ function normalizeIntentPayload({ agentId, jsonBody, merged, }) {
         bodyDestination,
         overlayChannel,
         overlayThreadTs,
+        overlayRecipients: merged.recipients,
+        overlaySubject: merged.subject,
     });
-    const text = requireText(readTextField(jsonBody, merged), 'content.text');
+    const text = requireText(readTextField(jsonBody, merged), 'content.text', destination.kind === 'agent_email' ? 20 * 1024 : MAX_TEXT_CHARS);
+    if (destination.kind === 'agent_email') {
+        if (Buffer.byteLength(text, 'utf8') > 20 * 1024)
+            throw invalidIntent('Email body exceeds 20 KiB.');
+        const forbidden = ['from', 'cc', 'bcc', 'html', 'attachments', 'headers', 'replyTo'];
+        const content = jsonBody.content;
+        if (forbidden.some((key) => jsonBody[key] !== undefined || content?.[key] !== undefined))
+            throw invalidIntent('Agent email accepts plain text only; sender and headers are server-owned.');
+    }
     const idempotencyKey = optionalIdempotencyKey(merged.idempotencyKey ??
         jsonBody.idempotencyKey ??
         jsonBody['idempotency_key'] ??
@@ -778,10 +808,38 @@ function pickDestinationKind({ bodyDestination, overlayKind, }) {
     }
     throw invalidIntent(`destination.kind must be one of ${message_intent_1.CANONICAL_DESTINATION_KINDS.join(', ')} (got "${normalized}").`);
 }
-function buildDestination({ kind, bodyDestination, overlayChannel, overlayThreadTs, }) {
+function buildDestination({ kind, bodyDestination, overlayChannel, overlayThreadTs, overlayRecipients, overlaySubject, }) {
     if (kind === 'app_owner_dm' || kind === 'slack_owner_dm') {
         return { kind };
     }
+    if (kind === 'agent_email') {
+        const source = bodyDestination;
+        if (source &&
+            Object.keys(source).some((key) => !['kind', 'recipients', 'subject'].includes(key))) {
+            throw invalidIntent('agent_email accepts only recipients and subject.');
+        }
+        const rawRecipients = overlayRecipients ?? source?.recipients;
+        if (!Array.isArray(rawRecipients) || rawRecipients.length < 1 || rawRecipients.length > 5) {
+            throw invalidIntent('agent_email requires 1 to 5 recipients.');
+        }
+        const recipients = rawRecipients.map((value) => {
+            if (typeof value !== 'string' ||
+                value.length > 254 ||
+                !/^[^\s@<>]+@[^\s@<>]+\.[^\s@<>]+$/.test(value))
+                throw invalidIntent('Invalid email recipient.');
+            return value.toLowerCase();
+        });
+        if (new Set(recipients).size !== recipients.length)
+            throw invalidIntent('Email recipients must be distinct.');
+        const subject = overlaySubject ?? source?.subject;
+        if (typeof subject !== 'string' ||
+            !subject.trim() ||
+            subject.length > 200 ||
+            // eslint-disable-next-line no-control-regex -- Reject control characters in mail headers.
+            /[\r\n\x00-\x1f\x7f]/.test(subject))
+            throw invalidIntent('Email subject must be a single line of at most 200 characters.');
+        return { kind, recipients: recipients.sort(), subject: subject.trim() };
+    }
     const channelId = optionalString(overlayChannel ?? bodyDestination?.channelId);
     if (!channelId) {
         throw invalidIntent('slack_channel destinations require destination.channelId.');
@@ -905,6 +963,16 @@ function booleanFlagInput(argv, name, parsedValue) {
 }
 function canonicalIntentFromDestination({ agentId, idempotencyKey, destination, text, presentation, notificationPolicy, context, threadRootMessageId, embeds, }) {
     switch (destination.kind) {
+        case 'agent_email':
+            return {
+                protocolVersion: 1,
+                agentId,
+                intentType: 'status_update',
+                destination,
+                content: { text },
+                idempotencyKey,
+                ...(context ? { context } : {}),
+            };
         case 'app_owner_dm':
             return (0, message_intent_1.canonicalAppOwnerDmRequest)({
                 agentId,
@@ -947,13 +1015,13 @@ function resolveAgentInput(argValue, flagValue, merged, jsonBody) {
         { label: 'agentId in JSON input', value: fromBody ?? fromMerged },
     ]);
 }
-function requireText(value, field) {
+function requireText(value, field, maxChars = MAX_TEXT_CHARS) {
     if (typeof value !== 'string' || !value.trim()) {
         throw invalidIntent(`${field} is required.`);
     }
     const normalized = value.trim();
-    if (normalized.length > MAX_TEXT_CHARS) {
-        throw invalidIntent(`${field} must be ${MAX_TEXT_CHARS} characters or less.`);
+    if (normalized.length > maxChars) {
+        throw invalidIntent(`${field} must be ${maxChars} characters or less.`);
     }
     return normalized;
 }
@@ -1043,6 +1111,8 @@ function formatEnvelope(envelope) {
     return `Agent message intent for ${envelope.agent.id} → ${destination}: ${status}${suffix}.${presentation}`;
 }
 function describeDestination(destination) {
+    if (destination.kind === 'agent_email')
+        return `agent_email:${destination.recipients.join(', ')}`;
     if (destination.kind === 'slack_channel') {
         return `slack_channel:${destination.channelId}${destination.threadTs ? `:${destination.threadTs}` : ''}`;
     }

package/dist/commands/agents/chat.js

@@ -594,7 +594,7 @@ class AgentsChat extends base_command_1.BaseCommand {
                     'status is not managed for you. The runtime session is bound to this task for ' +
                     'task context and artifact uploads; use the canonical id above.',
             ].join('\n');
-            if (!flags.jsonl) {
+            if (!flags.jsonl && !flags.json) {
                 this.log(`Bound to task ${task.identifier ?? taskId} (chat turn — task not checked out)`);
             }
         }

package/dist/commands/agents/create.d.ts

@@ -124,9 +124,6 @@ export default class AgentsCreate extends BaseCommand {
         avatar: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'conversation-starter': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'todo-working-hours': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'reasoning-tool-escape': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'commitment-responsibility': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'commitment-responsibility-ceiling': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'max-turns': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'tool-resources': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'install-channel': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/agents/create.js

@@ -280,32 +280,6 @@ class AgentsCreate extends base_command_1.BaseCommand {
             description: 'When this agent schedules its own work: HH:MM-HH:MM[@<IANA timezone>], e.g. ' +
                 '09:00-18:00@America/Los_Angeles',
         }),
-        // Retired (OSK-11975): a Commitment turn works under the Agent's own
-        // permissions. Hidden, warned on use, and never sent (OSK-12068) — see
-        // `mergeAgentConfigFlags`. Kept parseable so an old script still runs.
-        'reasoning-tool-escape': core_1.Flags.string({
-            description: "Retired — has no effect and is not sent. Commitment runs use the agent's own permissions.",
-            options: [...agent_config_1.REASONING_TOOL_ESCAPES],
-            multiple: true,
-            deprecated: { message: (0, agent_config_1.retiredCommitmentPermissionFlagMessage)('reasoning-tool-escape') },
-            hidden: true,
-        }),
-        'commitment-responsibility': core_1.Flags.string({
-            description: "Retired — has no effect and is not sent. Commitment runs use the agent's own permissions.",
-            options: [...agent_config_1.COMMITMENT_RESPONSIBILITY_LEVELS],
-            deprecated: {
-                message: (0, agent_config_1.retiredCommitmentPermissionFlagMessage)('commitment-responsibility'),
-            },
-            hidden: true,
-        }),
-        'commitment-responsibility-ceiling': core_1.Flags.string({
-            description: "Retired — has no effect and is not sent. Commitment runs use the agent's own permissions.",
-            options: [...agent_config_1.COMMITMENT_RESPONSIBILITY_LEVELS],
-            deprecated: {
-                message: (0, agent_config_1.retiredCommitmentPermissionFlagMessage)('commitment-responsibility-ceiling'),
-            },
-            hidden: true,
-        }),
         'max-turns': core_1.Flags.integer({ description: 'Maximum turns in one agent run (1-500)' }),
         'tool-resources': core_1.Flags.string({
             description: 'Tool resources JSON object (file_search / context / image_edit bindings)',

package/dist/commands/agents/egress.d.ts

@@ -0,0 +1,17 @@
+import { BaseCommand } from '../../base-command';
+export default class AgentsEgress extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        allow: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        remove: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        repo: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'remove-repo': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        clear: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}