typeclaw 0.33.0 → 0.34.0

package/auth.schema.json

@@ -276,6 +276,72 @@
             }
           }
         },
+        "line": {
+          "type": "object",
+          "properties": {
+            "currentAccount": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "accounts": {
+              "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
+              "additionalProperties": {
+                "type": "object",
+                "properties": {
+                  "account_id": {
+                    "type": "string"
+                  },
+                  "auth_token": {
+                    "type": "string"
+                  },
+                  "certificate": {
+                    "type": "string"
+                  },
+                  "device": {
+                    "type": "string",
+                    "enum": [
+                      "DESKTOPWIN",
+                      "DESKTOPMAC",
+                      "ANDROID",
+                      "ANDROIDSECONDARY",
+                      "IOS",
+                      "IOSIPAD"
+                    ]
+                  },
+                  "display_name": {
+                    "type": "string"
+                  },
+                  "created_at": {
+                    "type": "string"
+                  },
+                  "updated_at": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "account_id",
+                  "auth_token",
+                  "device",
+                  "created_at",
+                  "updated_at"
+                ]
+              }
+            }
+          },
+          "required": [
+            "currentAccount",
+            "accounts"
+          ]
+        },
         "kakaotalk": {
           "type": "object",
           "properties": {

package/cron.schema.json

@@ -22,6 +22,19 @@
                 "type": "string",
                 "minLength": 1
               },
+              "at": {
+                "type": "string",
+                "minLength": 1
+              },
+              "until": {
+                "type": "string",
+                "minLength": 1
+              },
+              "count": {
+                "type": "integer",
+                "exclusiveMinimum": 0,
+                "maximum": 9007199254740991
+              },
               "enabled": {
                 "default": true,
                 "type": "boolean"
@@ -49,7 +62,6 @@
             },
             "required": [
               "id",
-              "schedule",
               "kind",
               "prompt"
             ]
@@ -66,6 +78,19 @@
                 "type": "string",
                 "minLength": 1
               },
+              "at": {
+                "type": "string",
+                "minLength": 1
+              },
+              "until": {
+                "type": "string",
+                "minLength": 1
+              },
+              "count": {
+                "type": "integer",
+                "exclusiveMinimum": 0,
+                "maximum": 9007199254740991
+              },
               "enabled": {
                 "default": true,
                 "type": "boolean"
@@ -92,7 +117,6 @@
             },
             "required": [
               "id",
-              "schedule",
               "kind",
               "command"
             ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeclaw",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "homepage": "https://github.com/typeclaw/typeclaw#readme",
   "bugs": {
     "url": "https://github.com/typeclaw/typeclaw/issues"

package/secrets.schema.json

@@ -276,6 +276,72 @@
             }
           }
         },
+        "line": {
+          "type": "object",
+          "properties": {
+            "currentAccount": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "accounts": {
+              "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
+              "additionalProperties": {
+                "type": "object",
+                "properties": {
+                  "account_id": {
+                    "type": "string"
+                  },
+                  "auth_token": {
+                    "type": "string"
+                  },
+                  "certificate": {
+                    "type": "string"
+                  },
+                  "device": {
+                    "type": "string",
+                    "enum": [
+                      "DESKTOPWIN",
+                      "DESKTOPMAC",
+                      "ANDROID",
+                      "ANDROIDSECONDARY",
+                      "IOS",
+                      "IOSIPAD"
+                    ]
+                  },
+                  "display_name": {
+                    "type": "string"
+                  },
+                  "created_at": {
+                    "type": "string"
+                  },
+                  "updated_at": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "account_id",
+                  "auth_token",
+                  "device",
+                  "created_at",
+                  "updated_at"
+                ]
+              }
+            }
+          },
+          "required": [
+            "currentAccount",
+            "accounts"
+          ]
+        },
         "kakaotalk": {
           "type": "object",
           "properties": {

package/src/agent/index.ts

@@ -67,6 +67,7 @@ import {
   wrapAgentToolWithBudget,
   wrapToolDefinitionWithBudget,
 } from './tool-result-budget'
+import { createChannelDisengageTool } from './tools/channel-disengage'
 import { createChannelFetchAttachmentTool } from './tools/channel-fetch-attachment'
 import { createChannelHistoryTool } from './tools/channel-history'
 import { createChannelReactTool } from './tools/channel-react'
@@ -621,9 +622,11 @@ export function formatRestartNoticeOriginating(restartedAt: string): string {
 }
 
 // Builds the channel tool subset: channel_send (always when a router is
-// available), plus channel_reply + channel_history + skip_response (only
-// when the session origin is a channel — those rely on origin-bound
-// addressing or per-session turn state). Extracted from
+// available), plus the origin-bound channel tools when the session origin is
+// a channel — channel_reply, channel_history, channel_react,
+// channel_fetch_attachment, look_at_channel_attachment, channel_disengage, and
+// (when sessionId is known) skip_response. Those rely on origin-bound
+// addressing or per-session turn state. Extracted from
 // createSessionWithDispose so composition can be unit-tested without
 // going through createAgentSession / auth.
 //
@@ -683,6 +686,7 @@ export function buildChannelTools(
       }),
     )
     tools.push(createChannelLookAtTool(channelRouter, channelOrigin))
+    tools.push(createChannelDisengageTool({ router: channelRouter, origin: channelOrigin }))
     if (sessionId !== undefined) {
       tools.push(createSkipResponseTool({ router: channelRouter, sessionId }))
     }

package/src/agent/session-origin.ts

@@ -156,6 +156,7 @@ const PLATFORM_INFO: Record<AdapterId, PlatformInfo> = {
     supportsReactions: false,
     supportsAttachments: true,
   },
+  line: { displayName: 'LINE', mentionMode: 'alias', supportsReactions: false, supportsAttachments: false },
   kakaotalk: { displayName: 'KakaoTalk', mentionMode: 'alias', supportsReactions: false, supportsAttachments: true },
 }
 
@@ -425,6 +426,22 @@ function renderChannelOrigin(
     '  have no reason worth recording. Any other visible text without a',
     '  channel tool call is blocked.',
     '',
+    'Both of the above silence only the CURRENT turn. To stop being pulled',
+    'back into FUTURE turns, use the engagement tool below.',
+    '',
+    '- **`channel_disengage()`** — drop "mid-conversation" stickiness for this',
+    '  conversation. After you reply to someone, their next message re-engages',
+    '  you without an @mention, and that is renewed on every reply — so in a',
+    '  busy group you can get stuck answering turn after turn even after being',
+    '  told to stop. Call this when a human or peer bot asks you to be quiet /',
+    '  stop replying, or when you notice you are in a redundant loop. After',
+    '  disengaging you only re-engage when explicitly addressed again (mention,',
+    '  reply, or DM). It sends no message and does not affect other channels.',
+    '  ORDER MATTERS: if you want to ack ("ok, backing off") before going quiet,',
+    "  send that `channel_reply` FIRST, THEN call `channel_disengage` — it's the",
+    '  natural terminal action for the turn. Pair it with `skip_response` when',
+    '  you also want to stay silent this turn.',
+    '',
     '**Every user-facing sentence goes through `channel_reply`.** Narrating in',
     'plain text — "bumping to 16x now", "let me check that" — does NOT reach the',
     'user; it is invisible. If you want the user to see it, it is a',

package/src/agent/subagent-completion-reminder.ts

@@ -15,6 +15,7 @@ export type CompletionReminderArgs = {
   ok: boolean
   durationMs: number
   error?: string
+  hasRecoverableOutput?: boolean
   channel?: boolean
   adapter?: string
 }
@@ -55,10 +56,14 @@ export function renderSubagentCompletionReminder(args: CompletionReminderArgs):
     )
   }
   const err = args.error ?? 'unknown error'
+  const recoveryHint =
+    args.hasRecoverableOutput === true
+      ? `It produced output before failing — call subagent_output to recover it instead of redoing the work. `
+      : `Use subagent_output to inspect. `
   return (
     `<system-reminder>\n` +
     `Subagent \`${args.subagent}\` (${args.taskId}) FAILED after ${durationStr}: ${err}. ` +
-    `Use subagent_output to inspect. If this work was tracked in your todo list, ` +
+    `${recoveryHint}If this work was tracked in your todo list, ` +
     `keep the item pending (or add a recovery item) via todo_write so it is not ` +
     `dropped.${channelTail}\n` +
     `</system-reminder>`
@@ -88,6 +93,12 @@ export type SubagentCompletedPayload = {
   ok: boolean
   durationMs: number
   error?: string
+  // A failed subagent can still carry a recoverable result (e.g. a researcher
+  // that produced its `<report>` then timed out). The boolean — not the content
+  // — rides the broadcast so the reminder can tell the parent to fetch it via
+  // subagent_output; the body stays in the registry retrieval path, off the
+  // broadcast bus, to keep large/sensitive output out of every subscriber.
+  hasRecoverableOutput?: boolean
   // Present when the parent was a channel session. Lets the router fall back
   // to the live successor session for the same channel key when the parent
   // rolled over (SESSION_FRESHNESS_TTL_MS) or was idle-evicted while the
@@ -109,6 +120,7 @@ export function parseSubagentCompletedPayload(payload: unknown): SubagentComplet
     ok?: unknown
     durationMs?: unknown
     error?: unknown
+    hasRecoverableOutput?: unknown
     channelKey?: unknown
   }
   if (p.kind !== 'subagent.completed') return null
@@ -121,6 +133,7 @@ export function parseSubagentCompletedPayload(payload: unknown): SubagentComplet
     ok: p.ok === true,
     durationMs: typeof p.durationMs === 'number' ? p.durationMs : 0,
     ...(typeof p.error === 'string' ? { error: p.error } : {}),
+    ...(p.hasRecoverableOutput === true ? { hasRecoverableOutput: true } : {}),
     ...(channelKey !== null ? { channelKey } : {}),
   }
 }

package/src/agent/subagent-drain.ts

@@ -71,12 +71,14 @@ function collectPendingReminders(drain: SubagentBackgroundDrain, delivered: Set<
     if (child.status === 'running') continue
     if (delivered.has(child.taskId)) continue
     const completion = child.completion
+    const hasRecoverableOutput = child.status !== 'completed' && completion?.finalMessage !== undefined
     const text = renderSubagentCompletionReminder({
       subagent: child.subagentName,
       taskId: child.taskId,
       ok: child.status === 'completed',
       durationMs: completion?.durationMs ?? 0,
       ...(completion?.error !== undefined ? { error: completion.error } : {}),
+      ...(hasRecoverableOutput ? { hasRecoverableOutput: true } : {}),
     })
     pending.push({ taskId: child.taskId, text })
   }

package/src/agent/subagents.ts

@@ -360,7 +360,7 @@ export type SubagentHandle = {
 
 export type StartSubagentResult = {
   handle: Promise<SubagentHandle>
-  completion: Promise<{ ok: true; finalMessage?: string } | { ok: false; error: string }>
+  completion: Promise<{ ok: true; finalMessage?: string } | { ok: false; error: string; finalMessage?: string }>
 }
 
 export type StartSubagentOptions = InvokeSubagentOptions & {
@@ -427,7 +427,8 @@ export function startSubagent(name: string, options: StartSubagentOptions): Star
     })
 
   const timeoutMs = options.registry[name]?.timeoutMs
-  const completion = timeoutMs === undefined ? work : raceSubagentCompletion(work, name, options.taskId, timeoutMs)
+  const completion =
+    timeoutMs === undefined ? work : raceSubagentCompletion(work, name, options.taskId, timeoutMs, () => finalMessage)
 
   void completion.then(() => {
     if (timeoutMs !== undefined) void abortSession?.()
@@ -436,20 +437,33 @@ export function startSubagent(name: string, options: StartSubagentOptions): Star
   return { handle, completion }
 }
 
-type SubagentCompletion = { ok: true; finalMessage?: string } | { ok: false; error: string }
+type SubagentCompletion = { ok: true; finalMessage?: string } | { ok: false; error: string; finalMessage?: string }
 
+// `getFinalMessage` is read INSIDE the timeout callback, not at race-construction
+// time, so the timed-out result carries whatever the subagent had captured by the
+// moment the timer fired (e.g. a researcher's `<report>` block emitted just before
+// the kill). JS is single-threaded, so this read is torn-free; it preserves only
+// what an assistant `message_end` already committed — a result still mid-stream
+// when the timer fires cannot be recovered. The outcome stays `ok: false`: a
+// timeout is a lifecycle failure, and `finalMessage` here is recovery data for
+// the parent to inspect/re-persist, not proof the subagent honored its contract.
 function raceSubagentCompletion(
   work: Promise<SubagentCompletion>,
   name: string,
   taskId: string,
   timeoutMs: number,
+  getFinalMessage: () => string | undefined,
 ): Promise<SubagentCompletion> {
   let timer: ReturnType<typeof setTimeout> | null = null
   const timeout = new Promise<SubagentCompletion>((resolve) => {
-    timer = setTimeout(
-      () => resolve({ ok: false, error: new SubagentTimeoutError(name, taskId, timeoutMs).message }),
-      timeoutMs,
-    )
+    timer = setTimeout(() => {
+      const finalMessage = getFinalMessage()
+      resolve({
+        ok: false,
+        error: new SubagentTimeoutError(name, taskId, timeoutMs).message,
+        ...(finalMessage !== undefined ? { finalMessage } : {}),
+      })
+    }, timeoutMs)
   })
   return Promise.race([work, timeout]).finally(() => {
     if (timer !== null) clearTimeout(timer)

package/src/agent/tools/channel-disengage.ts

@@ -0,0 +1,66 @@
+import { Type } from '@mariozechner/pi-ai'
+import { defineTool } from '@mariozechner/pi-coding-agent'
+
+import type { ChannelRouter } from '@/channels/router'
+import type { AdapterId } from '@/channels/schema'
+
+export type ChannelDisengageOrigin = {
+  adapter: AdapterId
+  workspace: string
+  chat: string
+  thread: string | null
+}
+
+export type CreateChannelDisengageToolOptions = {
+  router: ChannelRouter
+  origin: ChannelDisengageOrigin
+}
+
+export type ChannelDisengageDetails = {
+  ok: boolean
+  cleared: number
+}
+
+// `channel_disengage` drops the "we're mid-conversation" sticky credits for the
+// current channel/thread. Stickiness force-engages the bot on a participant's
+// follow-up even without an @mention, and every reply re-grants a fresh credit —
+// so in a busy group the bot keeps answering turn after turn, even after a human
+// or peer bot asks it to stop. Calling this returns the bot to strict
+// mention/reply/dm engagement for this conversation until someone addresses it
+// again. Use it as a clean exit when you've been told to back off or when you
+// notice you're stuck in a redundant back-and-forth.
+export function createChannelDisengageTool({ router, origin }: CreateChannelDisengageToolOptions) {
+  return defineTool({
+    name: 'channel_disengage',
+    label: 'Channel Disengage',
+    description:
+      'Stop auto-engaging on follow-up messages in THIS channel/thread. While engaged you ' +
+      "keep replying to a participant's next message without an @mention, and that " +
+      'engagement is renewed every time you reply — so in a group you can get stuck ' +
+      'answering turn after turn even after someone tells you to stop. Call this when a ' +
+      'human or peer bot asks you to be quiet / stop replying, or when you realize you are ' +
+      'in a redundant loop. After disengaging, you only re-engage in this conversation when ' +
+      'explicitly addressed again (mention, reply, or DM). This does not send any message ' +
+      'and does not affect other channels. Pair it with skip_response when you also want to ' +
+      'stay silent on the current turn.',
+    parameters: Type.Object({}),
+
+    async execute() {
+      const result = router.clearSticky({
+        adapter: origin.adapter,
+        workspace: origin.workspace,
+        chat: origin.chat,
+        thread: origin.thread,
+      })
+      const details: ChannelDisengageDetails = { ok: true, cleared: result.cleared }
+      const summary =
+        result.cleared > 0
+          ? `Disengaged from this conversation (${result.cleared} active engagement${result.cleared === 1 ? '' : 's'} dropped). You will only re-engage here when explicitly addressed again.`
+          : 'You were not auto-engaged in this conversation; nothing to drop. You already only engage here when explicitly addressed.'
+      return {
+        content: [{ type: 'text' as const, text: summary }],
+        details,
+      }
+    },
+  })
+}

package/src/agent/tools/channel-log.ts

@@ -1,7 +1,8 @@
 // Shared logger surface for the channel_* agent tools.
 //
-// Until now, channel_send / channel_reply / channel_history /
-// channel_fetch_attachment swallowed every failure into the model-visible
+// Until now, the channel tools (channel_send / channel_reply /
+// channel_history / channel_fetch_attachment / channel_disengage / ...)
+// swallowed every failure into the model-visible
 // tool result and emitted nothing to the container's stdout/stderr. That
 // made operator-side debugging blind: a Slack send that 403'd, a
 // `thread-scope-requires-thread-session` denial, or a Discord attachment

package/src/agent/tools/spawn-subagent.ts

@@ -29,7 +29,7 @@ export type SpawnSubagentToolDetails =
       taskId: string
       sessionId: string | undefined
     }
-  | { ok: false; error: string }
+  | { ok: false; error: string; finalMessage?: string }
 
 export type CreateSpawnSubagentToolOptions = {
   registry: SubagentRegistry
@@ -167,6 +167,7 @@ export function createSpawnSubagentTool(options: CreateSpawnSubagentToolOptions)
         const durationMs = now() - startedAt
         liveRegistry.recordCompletion(taskId, completionToFinalShape(c, durationMs))
         if (stream && background) {
+          const hasRecoverableOutput = !c.ok && c.finalMessage !== undefined
           stream.publish({
             target: { kind: 'broadcast' },
             payload: {
@@ -177,6 +178,7 @@ export function createSpawnSubagentTool(options: CreateSpawnSubagentToolOptions)
               ok: c.ok,
               durationMs,
               ...(c.ok ? {} : { error: c.error }),
+              ...(hasRecoverableOutput ? { hasRecoverableOutput: true } : {}),
               ...(channelKey !== undefined ? { channelKey } : {}),
             },
           })
@@ -205,9 +207,22 @@ export function createSpawnSubagentTool(options: CreateSpawnSubagentToolOptions)
       const result = await completion
       const durationMs = now() - startedAt
       if (!result.ok) {
-        const details: SpawnSubagentToolDetails = { ok: false, error: result.error }
+        const details: SpawnSubagentToolDetails = {
+          ok: false,
+          error: result.error,
+          ...(result.finalMessage !== undefined ? { finalMessage: result.finalMessage } : {}),
+        }
+        const recovered =
+          result.finalMessage !== undefined
+            ? ` It produced output before failing; recover it below instead of redoing the work:\n\n${result.finalMessage}`
+            : ''
         return {
-          content: [{ type: 'text' as const, text: `${subagentName} failed after ${durationMs}ms: ${result.error}` }],
+          content: [
+            {
+              type: 'text' as const,
+              text: `${subagentName} failed after ${durationMs}ms: ${result.error}.${recovered}`,
+            },
+          ],
           details,
         }
       }
@@ -312,13 +327,18 @@ function hasPermissionForSubagent(
 }
 
 function completionToFinalShape(
-  c: { ok: true; finalMessage?: string } | { ok: false; error: string },
+  c: { ok: true; finalMessage?: string } | { ok: false; error: string; finalMessage?: string },
   durationMs: number,
 ): SubagentCompletion {
   if (c.ok) {
     return { ok: true, durationMs, ...(c.finalMessage !== undefined ? { finalMessage: c.finalMessage } : {}) }
   }
-  return { ok: false, error: c.error, durationMs }
+  return {
+    ok: false,
+    error: c.error,
+    durationMs,
+    ...(c.finalMessage !== undefined ? { finalMessage: c.finalMessage } : {}),
+  }
 }
 
 type ToolReturn = {

package/src/agent/tools/subagent-output.ts

@@ -37,6 +37,7 @@ export type SubagentOutputToolDetails =
       subagent: string
       durationMs: number
       error: string
+      finalMessage?: string
     }
   | { ok: false; error: string }
 
@@ -137,6 +138,7 @@ function renderSnapshot(snap: StatusSnapshot): ToolReturn {
     }
   }
   const error = snap.completion?.error ?? 'unknown error'
+  const finalMessage = snap.completion?.finalMessage
   const details: SubagentOutputToolDetails = {
     ok: true,
     status: 'failed',
@@ -144,9 +146,19 @@ function renderSnapshot(snap: StatusSnapshot): ToolReturn {
     subagent: snap.subagentName,
     durationMs: snap.completion?.durationMs ?? snap.elapsedMs,
     error,
+    ...(finalMessage !== undefined ? { finalMessage } : {}),
   }
+  const recovered =
+    finalMessage !== undefined
+      ? ` It produced output before failing; recover it below instead of redoing the work:\n\n${finalMessage}`
+      : ''
   return {
-    content: [{ type: 'text' as const, text: `${snap.subagentName} failed after ${details.durationMs}ms: ${error}` }],
+    content: [
+      {
+        type: 'text' as const,
+        text: `${snap.subagentName} failed after ${details.durationMs}ms: ${error}.${recovered}`,
+      },
+    ],
     details,
   }
 }

package/src/bundled-plugins/guard/policies/managed-config.ts

@@ -71,7 +71,7 @@ function validateManagedContent(file: ManagedFile, content: string): { ok: true
     const result = parseConfigJson(content, { migrate: false })
     return result.ok ? { ok: true } : { ok: false, reason: result.reason }
   }
-  const result = parseCronJson(content)
+  const result = parseCronJson(content, { mode: 'edit' })
   return result.ok ? { ok: true } : { ok: false, reason: result.reason }
 }
 

package/src/bundled-plugins/memory/memory-logger.ts

@@ -307,6 +307,13 @@ export function createMemoryLoggerSubagent(
   const logger = options.logger ?? consoleLogger
   return {
     systemPrompt: MEMORY_LOGGER_SYSTEM_PROMPT,
+    // Logging is "read transcript past the watermark, decide 0-N fragments,
+    // append" — mechanical extraction, no deep reasoning. Without this it fell
+    // back to `default`, sharing the slow reasoning model that a concurrent
+    // `researcher` pass saturates, which made the 50s spawn timeout fire under
+    // load. `fast` matches `memory-retrieval` (same I/O-bound shape) and itself
+    // falls back to `default` with a one-time warning when unconfigured.
+    profile: 'fast',
     tools: [readTool],
     customTools: [findEntryTool, appendTool, advanceWatermarkTool],
     payloadSchema: memoryLoggerPayloadSchema,

package/src/bundled-plugins/researcher/researcher.ts

@@ -25,17 +25,20 @@ import { createWriteReportTool } from './write-report'
 // `./skills/`; no runtime change required.
 export const RESEARCHER_SKILLS: readonly LoadableSkill[] = [GENERAL_RESEARCH_SKILL]
 
-// Mirrors the reviewer ceiling. A researcher whose `session.prompt` stalls
-// mid-turn would otherwise leave `completion` pending forever — the
-// `subagent.completed` broadcast never fires and the parent is never woken to
-// read the report. The ceiling makes `awaitWithSubagentTimeout` settle with
-// SubagentTimeoutError, surfacing a FAILED completion reminder so the request
-// fails loudly instead of vanishing. Sized for a thorough `deep`-model pass
-// (multi-source gathering, a few delegated workers, writing a report file),
-// well above a typical sub-minute lookup. This is liveness for the parent, not
-// hard cancellation: pi's `session.prompt` takes no AbortSignal, so the LLM
-// stream may run until the OS reaps it. See src/agent/subagents.ts `timeoutMs`.
-export const RESEARCHER_SPAWN_TIMEOUT_MS = 600_000
+// A researcher whose `session.prompt` stalls mid-turn would otherwise leave
+// `completion` pending forever and never wake the parent. This ceiling makes
+// the spawn settle with SubagentTimeoutError, surfacing a completion reminder
+// so the request resolves loudly instead of vanishing.
+//
+// 30m, not the prior 10m: a real pass spent ~2.5m composing its scout fan-out,
+// ~4–7m on 4 parallel scouts, then was killed ~2s into the final `write_report`
+// — discarding a finished report. The `deep` profile trades speed for quality,
+// so nested scout warmup + multi-source gathering + synthesis routinely exceed
+// 10m. This is liveness, not hard cancellation: `session.prompt` takes no
+// AbortSignal, so the stream may run until the OS reaps it. A report produced
+// before the ceiling is no longer lost — see startSubagent's finalMessage
+// preservation in src/agent/subagents.ts.
+export const RESEARCHER_SPAWN_TIMEOUT_MS = 1_800_000
 
 // TODO(#452): Restrict the researcher's `bash` to a curated read-only allowlist
 // once per-subagent bash allowlist support lands. Today the read-only contract

package/src/bundled-plugins/security/policies/outbound-secret-scan.ts

@@ -55,6 +55,7 @@ const PROCESS_ENV_TARGETS: ReadonlyArray<string> = [
   'OPENAI_API_KEY',
   'ANTHROPIC_API_KEY',
   'MINIMAX_API_KEY',
+  'DEEPSEEK_API_KEY',
   'GOOGLE_API_KEY',
   'GEMINI_API_KEY',
   'AWS_ACCESS_KEY_ID',