cli-jaw 2.17.43 → 2.17.44

package/dist/src/agent/spawn.js

@@ -1,3 +1,5 @@
+import { calendarContext } from './calendar-context.js';
+import { createSlackToolSecretStream, activateSlackToolGrant, revokeSlackToolGrant, revokeSlackToolScope, redactSlackToolSecrets, SLACK_TOOL_GRANT_ENV } from '../slack/tool-context.js';
 // ─── Agent Spawn + Kill/Steer/Queue ──────────────────
 import fs from 'fs';
 import os from 'os';
@@ -60,6 +62,7 @@ import { PiProjection } from './runtime/pi-projection.js';
 import { PiRawTrace } from './runtime/pi-raw-trace.js';
 import { createPrintActivity, finishPrintActivity } from './runtime/print-activity.js';
 import { isNativeAdapterImplemented, isNativeWorkerImplemented, isSwitchableNativeCli, resolveRuntimeTransport, runtimeSessionBucket } from './runtime/selection.js';
+import { clearNativeStartFailure, nativeStartFailure, recordNativeStartFailure } from './runtime/start-failure.js';
 import { asCliEventRecord, discriminate, fieldString } from '../types/cli-events.js';
 import { isRemoteTarget } from '../messaging/types.js';
 import { buildRemoteBindingKey } from '../messaging/session-key.js';
@@ -470,6 +473,10 @@ function clearMainLiveRunOnStop(scopeKey, reason) {
 export function killActiveAgent(scopeKeyOrReason = 'user', scopedReason) {
     const scopeKey = scopedReason === undefined ? 'default' : scopeKeyOrReason;
     const reason = scopedReason ?? scopeKeyOrReason;
+    if (reason === 'user' || reason === 'api')
+        revokeSlackToolScope(scopeKey);
+    else
+        revokeSlackToolGrant(activeMainProcesses.get(scopeKey)?.meta?.requestId);
     cancelSteerInputs(scopeKey);
     const cancelledClaude = cancelClaudeScope(scopeKey, reason, reason === 'api' || reason === 'user');
     const run = activeMainProcesses.get(scopeKey);
@@ -734,6 +741,12 @@ export async function steerAgent(scopeKey, newPrompt, source, meta) {
         settleOnce(meta?.requestId, 'steered');
         return 'steered';
     }
+    // Capture the admitted Slack address before kill/wait can yield ownership.
+    const slackRestart = source === 'slack' && isRemoteTarget(meta?.target) && meta.target.channel === 'slack'
+        ? stripUndefined({ mode: 'restart', scope: scopeKey, sessionId: chatSessionId,
+            target: { ...meta.target }, chatId: meta.chatId, requestId: meta.requestId,
+            remoteKey: meta.remoteKey, replyViaTarget: true })
+        : undefined;
     const steerWaitMs = getSteerWaitMsForActiveAgent(scopeKey);
     // Snapshot BEFORE the kill: the interrupted partial-output row is identified
     // as the first ⏹️-tagged assistant message with id above this mark. A
@@ -769,19 +782,16 @@ export async function steerAgent(scopeKey, newPrompt, source, meta) {
     broadcast('new_message', { role: 'user', content: newPrompt, source, scope: scopeKey, sessionId: chatSessionId });
     broadcast('steer_started', stripUndefined({ prompt: newPrompt, origin: source || 'web', scope: scopeKey,
         sessionId: chatSessionId, target: meta?.target, chatId: meta?.chatId, requestId: meta?.requestId,
-        remoteKey: meta?.remoteKey, replyViaTarget: meta?.replyViaTarget, mode: 'kill-steer' }));
+        remoteKey: meta?.remoteKey, replyViaTarget: meta?.replyViaTarget, mode: 'kill-steer', ...slackRestart }));
     const { orchestrate, orchestrateContinue, orchestrateReset, isContinueIntent, isResetIntent } = await import('../orchestrator/pipeline.js');
     const origin = source || 'web';
-    // The follow-up run answers the SAME conversation the killed turn came from,
-    // but nothing downstream can infer that: a remote caller's reply is addressed
-    // by `target`, and dropping it here left the answer with nowhere to go. The
-    // dispatch waiter is already gone (ingress returns early for a steered
-    // submission), so an unaddressed terminal is silently discarded and the
-    // channel just goes quiet after a steer.
+    // Union of both contracts: the #655 steer identity (target/chatId/remoteKey/
+    // replyViaTarget/_fromSteer) plus the #654 pre-kill capture (slackRestart),
+    // whose mode restart is what the reply-control observer treats as a start.
     const steerMeta = stripUndefined({ origin, scope: scopeKey, chatSessionId, requestId: meta?.requestId,
         target: meta?.target, chatId: meta?.chatId, remoteKey: meta?.remoteKey,
         replyViaTarget: meta?.replyViaTarget, _fromSteer: true,
-        _skipInsert: true, _steerContext: steerContext || undefined });
+        ...slackRestart, _skipInsert: true, _steerContext: steerContext || undefined });
     const task = isResetIntent(newPrompt)
         ? orchestrateReset(steerMeta)
         : isContinueIntent(newPrompt)
@@ -791,8 +801,8 @@ export async function steerAgent(scopeKey, newPrompt, source, meta) {
         console.error('[steer:orchestrate]', err.message);
         broadcast('orchestrate_done', stripUndefined({ text: `[error] ${err.message}`, error: true, origin,
             target: meta?.target, chatId: meta?.chatId, replyViaTarget: meta?.replyViaTarget,
-            fromSteer: true, requestId: meta?.requestId }));
-        settleOnce(meta?.requestId, 'failed', { error: err.message });
+            fromSteer: true, requestId: meta?.requestId, ...slackRestart }));
+        settleOnce(slackRestart ? slackRestart.requestId : meta?.requestId, 'failed', { error: err.message });
     });
     // The follow-up was started as a new run (kill-path or idle race). The caller
     // must NOT also queue the message.
@@ -846,6 +856,9 @@ export function makeCleanEnv(extraEnv = {}, inheritedEnv = process.env, platform
     // Same platform passthrough as above. This is the call that produces the
     // RETURNED PATH, so a win32/POSIX disagreement here reaches the child.
     merged["PATH"] = buildServicePath(extraPath || env["PATH"] || '', [], os.homedir(), platform);
+    for (const key of Object.keys(merged))
+        if (key.toUpperCase() === SLACK_TOOL_GRANT_ENV)
+            delete merged[key];
     return merged;
 }
 function buildHistoryBlock(currentPrompt, workingDir, chatSessionId, maxSessions = PROMPT_HISTORY_MAX_ROWS, maxTotalChars = PROMPT_HISTORY_MAX_CHARS) {
@@ -1295,7 +1308,7 @@ export function spawnAgent(prompt, opts = {}) {
             ? '\n(need history? L1: cli-jaw chat/memory search/context | L2: cli-jaw dashboard memory search, cli-jaw dashboard chat search)'
             : '';
         const promptWithConversation = prependRemoteConversationContext(prompt, opts.target);
-        prompt = `${ts}\n${projLine}${promptWithConversation}${memoryNudge}`;
+        prompt = `${ts}\n${calendarContext(_d)}\n${projLine}${promptWithConversation}${memoryNudge}`;
     }
     const resumeSessionId = empSid || (isResume ? bucketSessionId : null);
     const needsHistory = shouldBuildHistoryBlock({
@@ -1640,9 +1653,21 @@ export function spawnAgent(prompt, opts = {}) {
             text: outcome.finalText?.trim() ?? '', code: outcome.status === 'done' ? 0 : outcome.status === 'stopped' ? 130 : 1,
             runtimeOutcome: outcome, traceRunId,
         });
-        const diagnostic = () => grok ? 'Grok native runtime failed. Check the native model, effort and existing CLI login.' : facade?.lastError?.includes('config')
-            ? 'Cursor native model or effort is unsupported. Choose an advertised model/effort; Composer models may require an unset effort.'
-            : 'Cursor native runtime failed. Check the native model, effort and existing CLI login.';
+        // A runtime that never acquired a lease has no facade to ask, so the
+        // substring heuristic below could only ever produce the generic sentence
+        // for exactly the failures that need naming. The recorded start code is
+        // provider-independent by construction, so it decides the wording and is
+        // shown alongside it (#658).
+        const diagnostic = () => {
+            const code = nativeStarted ? undefined : nativeStartFailure(cli)?.code;
+            const named = code ? ` (${code})` : '';
+            if (grok)
+                return `Grok native runtime failed.${named} Check the native model, effort and existing CLI login.`;
+            const configFault = code ? code.startsWith('acp_config_') : facade?.lastError?.includes('config');
+            return configFault
+                ? `Cursor native model or effort is unsupported.${named} Choose an advertised model/effort; Composer models may require an unset effort.`
+                : `Cursor native runtime failed.${named} Check the native model, effort and existing CLI login.`;
+        };
         const startFailedRuntime = () => {
             if (!failedStart) {
                 failedStart = new RuntimeProjection(identity);
@@ -1752,6 +1777,8 @@ export function spawnAgent(prompt, opts = {}) {
                 if (!ownsRun())
                     throw new Error('native_run_owner_lost');
                 capturedRun.process = lease.child;
+                // This start reached its lease, so the previous start failure is spent.
+                clearNativeStartFailure(cli);
                 if (!opts._skipInsert)
                     insertMessage.run('user', prompt, cli, runtimeModel, nativeCwd, chatSessionId);
                 capturedRun.starting = false;
@@ -1858,7 +1885,14 @@ export function spawnAgent(prompt, opts = {}) {
                     await lease.retire(new Error('native_runtime_finalization_failed'));
                 return selectedResult ?? resultFor(ctx.runtimeOutcome ?? outcome);
             },
-            failed: (_error, _lease, outcome) => failRuntime(outcome),
+            failed: (error, lease, outcome) => {
+                // A null lease means acquire never returned: the runtime failed to
+                // start, which is the only class this diagnostic answers (#658).
+                // Teardown faults after a claimed answer are a different failure.
+                if (!lease)
+                    recordNativeStartFailure(cli, error);
+                return failRuntime(outcome);
+            },
             finalized: () => {
                 finalized = true;
                 try {
@@ -3354,6 +3388,10 @@ export function spawnAgent(prompt, opts = {}) {
     }
     // The snapshot has to predate the child; the helper owns that ordering (073 §2.4).
     const kiroPlainText = isKiroPlainTextCli(cli, effectiveProvider);
+    const slackToolGrant = !isEmployee && ['cursor', 'claude', 'codex', 'grok'].includes(cli)
+        ? activateSlackToolGrant(opts.requestId, scopeKey, chatSessionId) : undefined;
+    if (slackToolGrant)
+        launchEnv[SLACK_TOOL_GRANT_ENV] = slackToolGrant;
     const { child, kiroConversationIdsBefore, kiroSpawnStartedAt } = spawnWithKiroSnapshot({
         kiroPlainText,
         isFreshMainRun: !isResume && !empSid,
@@ -3593,6 +3631,7 @@ export function spawnAgent(prompt, opts = {}) {
         ctx.opencodeLastEventAt = Date.now();
     };
     const dispatchNdjsonLine = (line) => {
+        line = redactSlackToolSecrets(line);
         let raw;
         try {
             raw = JSON.parse(line);
@@ -3772,13 +3811,15 @@ export function spawnAgent(prompt, opts = {}) {
             dispatchNdjsonLine(line);
         }
     });
+    const slackStderr = slackToolGrant ? createSlackToolSecretStream() : undefined;
     child.stderr.on('data', (chunk) => {
         opts.lifecycle?.onActivity?.('stderr');
         clearAgyQuietCompletionTimer();
         lastOpencodeIoAt = Date.now();
         // No per-chunk trim: trimming a chunk destroys legitimate leading/trailing
         // whitespace and line boundaries that only exist across chunks (#372).
-        const text = stderrReader.write(chunk);
+        const decoded = stderrReader.write(chunk);
+        const text = slackStderr ? slackStderr(decoded) : decoded;
         if (!text)
             return;
         if (cli === 'agy')
@@ -3815,7 +3856,8 @@ export function spawnAgent(prompt, opts = {}) {
                 buffer += stdoutResidual;
             }
         }
-        const stderrResidual = stderrReader.end();
+        const stderrEnd = stderrReader.end();
+        const stderrResidual = slackStderr ? slackStderr(stderrEnd, true) : stderrEnd;
         if (stderrResidual && ctx.stderrBuf.length < STDERR_BUF_CAP) {
             ctx.stderrBuf = sliceWithoutSplittingSurrogate(ctx.stderrBuf + stderrResidual, STDERR_BUF_CAP);
         }