Merge remote-tracking branch 'origin/master' into feature/subagent-policy-inheritance

# Conflicts:
#	.agents/notes/implemented/feature/2026-07-06-sandbox.i18n.yaml
#	docs/cordis-catalog/services.md
#	docs/persistence-catalog.md
#	examples/acp-agent/tests/snapshots/cordis-inspect-jsdoc/session.jsonl
#	packages/core/session/README.i18n.yaml
#	packages/subagent/subagent-inprocess/README.i18n.yaml
#	packages/ui/user-approval/src/index.ts

examples/headless-agent/tests/fixtures/cli-mock-llm.ts

@@ -59,7 +59,7 @@ export const inject = ['llm']
 /** Register the keyless `cli-mock` adapter. */
 export function apply(ctx: Context): void {
   ctx.llm.registerAdapter(['cli-mock'], new CliMockAdapter())
-  ctx.on('agent/request', async (_agent, _turn, step, _config, _signal, next) => {
+  ctx.on('agent/request', async (_agent, _turn, step, _signal, next) => {
     const config = await next()
     return step === 2 ? { ...config, reasoningEffort: OFF } : config
   })

examples/headless-agent/tests/fixtures/goal-domain/seed-goal.ts

@@ -7,7 +7,7 @@ export const name = 'seed-goal'
 export const inject = ['goals']
 
 export function apply(ctx: Context): void {
-  ctx.on('agent/pre-step', (agent) => {
+  ctx.on('agent/step', (agent) => {
     if (ctx.goals.get(agent) !== undefined) return
     ctx.goals.create(agent, {
       objective: 'Prove the composed goal survives in the session log',

examples/headless-agent/tests/fixtures/retry-snapshot-backend.mjs

@@ -0,0 +1,53 @@
+/** Deterministic provider adapter for the headless retry-policy snapshot. */
+
+import {
+  LlmAdapter,
+  LlmError,
+  resolveRetryPolicy,
+} from '@deepseek-ai/dsh-llm'
+
+class RetrySnapshotAdapter extends LlmAdapter {
+  requests = 0
+  firstMessages
+  policy = resolveRetryPolicy({
+    mode: 'normal',
+    maxRetries: 1,
+    retryableCodes: ['RATE_LIMIT'],
+    backoff: { initialDelayMs: 1, maxDelayMs: 1, jitterRatio: 0 },
+  }, 'retry-snapshot-backend.retryPolicy')
+
+  providerRetryPolicy() {
+    return this.policy
+  }
+
+  async * stream(options) {
+    const messages = JSON.stringify(options.messages)
+    this.requests++
+    if (this.requests === 1) {
+      this.firstMessages = messages
+      throw new LlmError('snapshot transient failure', 'RATE_LIMIT', { status: 429 })
+    }
+    if (this.requests === 2 && messages !== this.firstMessages) {
+      throw new Error('retry snapshot changed the model-visible messages')
+    }
+    const text = 'RETRY_OK'
+    yield { type: 'block-start', index: 0, blockType: 'text' }
+    yield { type: 'text-delta', index: 0, text }
+    yield { type: 'block-end', index: 0, block: { type: 'text', text } }
+    yield { type: 'usage', usage: { inputTokens: 4, outputTokens: 2 } }
+    yield { type: 'finish', reason: { kind: 'stop' } }
+  }
+}
+
+/** Cordis plugin name. */
+export const name = 'retry-snapshot-backend'
+/** Required LLM registry service. */
+export const inject = ['llm']
+
+/**
+ * Register the deterministic provider adapter.
+ * @param {import('cordis').Context} ctx - plugin context carrying the LLM service.
+ */
+export function apply(ctx) {
+  ctx.llm.registerAdapter(['deepseek'], new RetrySnapshotAdapter())
+}

examples/headless-agent/tests/fixtures/telemetry-otel-driver.ts

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+/**
+ * Test driver: start a mock OTLP/HTTP collector, boot the telemetry Loader
+ * composition against it, run one turn whose prompt carries a fixture
+ * credential, then persist everything the collector captured to
+ * `./otlp-captures.json` for the e2e's inspect step.
+ */
+
+import { writeFile } from 'node:fs/promises'
+import { createServer } from 'node:http'
+import { once } from 'node:events'
+import { boot, resolveConfigPath } from '@deepseek-ai/dsh-app-boot'
+import { runOneShot } from '@deepseek-ai/dsh-cli-demo/src/cli.ts'
+
+const configPath = process.argv[2]
+if (configPath === undefined) throw new Error('telemetry-otel driver requires a config path')
+
+const captures: unknown[] = []
+const server = createServer((request, response) => {
+  const chunks: Buffer[] = []
+  request.on('data', chunk => chunks.push(chunk as Buffer))
+  request.on('end', () => {
+    captures.push(JSON.parse(Buffer.concat(chunks).toString()))
+    response.writeHead(200, { 'content-type': 'application/json' }).end('{}')
+  })
+})
+server.listen(0, '127.0.0.1')
+await once(server, 'listening')
+const address = server.address()
+if (address === null || typeof address === 'string') throw new Error('collector has no port')
+process.env.DSH_TELEMETRY_E2E_URL = `http://127.0.0.1:${address.port}/v1/logs`
+
+const ctx = await boot('telemetry-otel-e2e', resolveConfigPath(configPath, undefined))
+try {
+  // The fixture credential rides the model-visible user message; the exported
+  // copy must scrub it while the canonical log keeps the original bytes.
+  await runOneShot(ctx, { task: 'prove telemetry with key sk-e2efixture1234567890' })
+} finally {
+  await ctx.fiber.dispose()
+}
+await writeFile('./otlp-captures.json', JSON.stringify(captures))
+server.close()
+server.closeAllConnections()

examples/headless-agent/tests/fixtures/telemetry-otel.cordis.yml

@@ -0,0 +1,28 @@
+# Test-only composition: session-telemetry-otel through the real Loader/app
+# path, exporting to the mock OTLP collector the driver starts (url via env).
+# The redact-rule entry models a deployment mounting its own scrub rule on the
+# telemetry/record waterfall — the seam itself ships no rules.
+- id: cli-mock-llm
+  name: './cli-mock-llm.ts'
+
+- id: telemetry-redact-rule
+  name: './telemetry-redact-rule.ts'
+
+- id: bash
+  name: '@deepseek-ai/dsh-bash-local'
+
+- id: telemetry-otel
+  name: '@deepseek-ai/dsh-session-telemetry-otel'
+  config:
+    exporter:
+      url: !!js process.env.DSH_TELEMETRY_E2E_URL
+
+- id: cli-agent
+  name: '@deepseek-ai/dsh-cli-demo'
+  config:
+    provider: cli-mock
+    model: cli-mock
+    persona: 'Test the session-telemetry-otel plugin.'
+    persistenceRoot: './.sessions'
+    persistenceCompression: 'none'
+    workspaceContext: false

examples/headless-agent/tests/fixtures/telemetry-redact-rule.ts

@@ -0,0 +1,29 @@
+import type { Context } from 'cordis'
+
+/**
+ * Deployment-style redaction rule for the telemetry e2e: scrubs the fixture
+ * credential from body strings, exactly as a real deployment would mount its
+ * own rules on the `telemetry/record` waterfall.
+ */
+
+const SECRET = /sk-e2efixture[0-9]+/g
+const PLACEHOLDER = '[E2E-REDACTED]'
+
+function scrub(value: unknown): unknown {
+  if (typeof value === 'string') return value.replace(SECRET, PLACEHOLDER)
+  if (Array.isArray(value)) return value.map(scrub)
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, scrub(entry)]))
+  }
+  return value
+}
+
+export const name = 'telemetry-redact-rule'
+
+/** Mount the fixture scrub rule onto the redact waterfall. */
+export function apply(ctx: Context): void {
+  ctx.on('telemetry/record', (_record, next) => {
+    const record = next()
+    return { ...record, body: scrub(record.body) }
+  })
+}