@toddzheng024/dscode-bundle 0.7.26 → 0.7.28

package/plugins/auto-review/index.mjs

@@ -24,6 +24,9 @@ export function apply(ctx, config) {
   const calls = new WeakMap();
   const budgets = new WeakMap();
   const mode = agent => ctx.permissionPresets.current(agent.session);
+  // The preset this plugin reviews for. DSH 0.1.7 reserved `auto` for its own
+  // integration, so the reviewed preset carries DSCODE's own name.
+  const REVIEWED = 'auto-review';
   const stateFor = agent => {
     const events = agent.session.snapshotEvents();
     const turn = events.findLast(e => e.type === 'turn/start')?.seq;
@@ -54,7 +57,7 @@ export function apply(ctx, config) {
   });
 
   const announce = (agent, text) => agent.inject(createUserMessage({
-    content: [{ type: 'text', text }], source: { kind: 'plugin', plugin: name },
+    content: [{ type: 'text', text }], source: { kind: name },
   }));
   const record = (req, data) => {
     audit.append(req.agent.session.id, { sessionSeq: req.agent.session.seq, callId: req.callId ?? null, toolName: req.toolName, ...data });
@@ -64,7 +67,7 @@ export function apply(ctx, config) {
   async function review(req, next, state) {
     if (req.signal?.aborted) return 'cancelled';
     // A user can switch to ask while a prior review waits in the queue.
-    if (mode(req.agent) !== 'auto') return ctx.approval?.effectivePolicy?.(req.agent.session) === 'never' ? 'rejected' : next();
+    if (mode(req.agent) !== REVIEWED) return ctx.approval?.effectivePolicy?.(req.agent.session) === 'never' ? 'rejected' : next();
     const exec = calls.get(req.agent)?.get(req.callId);
     const fallback = async (reason, details = {}) => {
       record(req, { decision: 'human', reason, ...details });
@@ -82,7 +85,7 @@ export function apply(ctx, config) {
         record(req, { decision: 'cancelled', reason: 'Caller cancelled review.', ...details });
         return 'cancelled';
       }
-      if (mode(req.agent) !== 'auto') return fallback('Permission mode changed while review was pending.', details);
+      if (mode(req.agent) !== REVIEWED) return fallback('Permission mode changed while review was pending.', details);
       if (decision.decision === 'human') return fallback(decision.reason, details);
       // Bind approval to the still-pending immutable invocation; no grant cache.
       if (calls.get(req.agent)?.get(req.callId) !== exec || fingerprint(action) !== actionHash) return fallback('Pending action changed during review.', details);
@@ -174,7 +177,7 @@ export function apply(ctx, config) {
           ...(effort === undefined ? {} : { reasoningEffort: effort }),
           messages: [createSystemMessage(REVIEW_POLICY, name), createUserMessage({
             content: [{ type: 'text', text: JSON.stringify({ action, context }) }],
-            source: { kind: 'plugin', plugin: name },
+            source: { kind: name },
           })],
           maxTokens: config.maxOutputTokens, signal,
         })) {
@@ -231,7 +234,7 @@ export function apply(ctx, config) {
       }
       announce(req.agent, `Escalation budget reached (${grantBudget} per turn); asking the user.`);
     }
-    if (mode(req.agent) !== 'auto') return next();
+    if (mode(req.agent) !== REVIEWED) return next();
     const state = stateFor(req.agent);
     // Serialize per agent so simultaneous calls cannot race the denial budget.
     const pending = state.tail.then(() => review(req, next, state));

package/plugins/code-review/index.mjs

@@ -141,7 +141,7 @@ export async function independentReview(ctx, agent, options = {}, signal, collec
         for await (const chunk of ctx.llm.stream({
           provider: route.provider, model: route.model, reasoningEffort, purpose: 'review',
           maxTokens: tokens,
-          system: POLICY, messages: [createUserMessage({ content: [{ type: 'text', text: JSON.stringify(request) }], source: { kind: 'plugin', plugin: name } })], signal: deadline,
+          system: POLICY, messages: [createUserMessage({ content: [{ type: 'text', text: JSON.stringify(request) }], source: { kind: name } })], signal: deadline,
         })) {
           deadline.throwIfAborted();
           assembler.push(chunk);

package/plugins/computer-use/index.mjs

@@ -0,0 +1,37 @@
+/**
+ * Computer Use, mounted through DSCODE so a retired settings API still resolves.
+ *
+ * `@anionex/dsh-computer-use` reads its configuration with `ctx.settings.register`, an API
+ * DSH removed in 0.1.7: Settings now projects forms from the profile entry itself, and the
+ * missing method made the whole Computer Use bundle fail to activate. The package is
+ * pinned at 0.3.2 with no newer release, so this row restores the method — as a read-only
+ * view over the composition config, which is where DSCODE configures Computer Use anyway —
+ * and then mounts the upstream bundle as its child, which is what makes the order
+ * dependable: the shim is installed before the provider's constructor runs.
+ *
+ * Retire this wrapper when the package reads volatile configuration, and mount
+ * `@anionex/dsh-computer-use` directly again.
+ *
+ * @module dscode-computer-use
+ */
+
+import ComputerUseBundle from '@anionex/dsh-computer-use';
+
+export const name = 'dscode-computer-use';
+export const inject = ['settings'];
+
+/** Section handle the 0.3.x provider expects: one read of the composition config, no live writes. */
+function staticSection(base) {
+  return { get: () => base, watch: () => () => {} };
+}
+
+export function apply(ctx, config = {}) {
+  const settings = ctx.settings;
+  // Only ever adds what upstream no longer defines; a Settings service that carries its
+  // own `register` again is left untouched, and the shim is dropped with this row.
+  if (typeof settings.register !== 'function') {
+    settings.register = (_namespace, _schema, options = {}) => staticSection(options.base ?? {});
+    ctx.effect(() => () => { delete settings.register; });
+  }
+  ctx.plugin(ComputerUseBundle, config);
+}

package/plugins/cordis-config/plain.mjs

@@ -0,0 +1,31 @@
+/**
+ * One plain snapshot of a Cordis plugin configuration.
+ *
+ * Two shapes make a foreign entry's `config` unusable as a plain object. DSH 0.1.7 hands
+ * a `.volatile()` field to its own plugin as a reference rather than a value, and the
+ * Loader keeps a YAML `!!js` scalar as an unevaluated `{ __jsExpr }` node until the entry
+ * activates — which a reader inspecting another entry's row (the skills conflict report
+ * walks every `skill-filesystem` entry, and a preset's rows carry such expressions) sees
+ * instead of the value. References are read; an expression cannot be evaluated outside the
+ * Loader's own scope, so it reads as absent and the caller applies its own fallback.
+ *
+ * @param config - a configuration object whose fields may be references or expressions.
+ * @returns a shallow copy carrying only plainly readable values.
+ */
+export function plainConfig(config) {
+  if (config === null || typeof config !== 'object') return {};
+  const entries = Object.entries(config)
+    .map(([key, value]) => [key, isReference(value) ? value.get() : value])
+    .filter(([, value]) => !isExpression(value));
+  return Object.fromEntries(entries);
+}
+
+/** Whether a configuration field is a Cordis value reference rather than a plain value. */
+function isReference(value) {
+  return value !== null && typeof value === 'object' && typeof value.get === 'function';
+}
+
+/** Whether a configuration field is still an unevaluated Loader expression node. */
+function isExpression(value) {
+  return value !== null && typeof value === 'object' && '__jsExpr' in value;
+}

package/plugins/exec/cli.mjs

@@ -9,7 +9,7 @@ Options:
   --cwd DIR             workspace for the agent (default: current directory)
   --model PROVIDER/ID   model route (default: the saved default model)
   --effort LEVEL        reasoning effort the model offers: off, minimal, low, medium, high, xhigh, max or ultra
-  --permission PRESET   permission preset: auto, ask, workspace-write, read-only, danger-full-access
+  --permission PRESET   permission preset: auto-review, ask, workspace-write, read-only, danger-full-access
   --approve-all         answer every approval request with allow (no human is present)
   --resume SESSION_ID   continue an existing session instead of starting a new one
   --json                emit JSON lines (session, text, tool, result) instead of plain text

package/plugins/grok/index.mjs

@@ -1,6 +1,8 @@
 import z from "@deepseek-ai/schemastery";
 import { RetryPolicySchema, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { deepEqualJson } from "@deepseek-ai/dsh-util-values";
+import { plainConfig } from "../cordis-config/plain.mjs";
 import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
 import { GrokAdapter, PROVIDER } from "./adapter.mjs";
 import { ensureGrokModels } from "./models.mjs";
@@ -19,14 +21,18 @@ const DEFAULT_BASE_URL = "https://api.x.ai/v1";
 /** The client version the CLI proxy is asked with; xAI refuses requests without one. */
 const DEFAULT_CLIENT_VERSION = "1.0.34";
 
+// DSH 0.1.7 replaced settings sections with volatile configuration: each `.volatile()`
+// field arrives as a reference the Settings form and a profile edit both write, so the
+// reads below always see the current value.
 export const Config = z.object({
-  apiKeyEnv: z.string().role("credential-ref").default(GROK_TOKEN_REF),
-  baseURL: z.string().default(DEFAULT_BASE_URL),
-  clientVersion: z.string().default(DEFAULT_CLIENT_VERSION),
-  streamIdleTimeoutMs: z.number().min(1).default(300000),
-  retryPolicy: RetryPolicySchema,
+  apiKeyEnv: z.string().role("credential-ref").default(GROK_TOKEN_REF).volatile(),
+  baseURL: z.string().default(DEFAULT_BASE_URL).volatile(),
+  clientVersion: z.string().default(DEFAULT_CLIENT_VERSION).volatile(),
+  streamIdleTimeoutMs: z.number().min(1).default(300000).volatile(),
+  retryPolicy: RetryPolicySchema.volatile(),
 });
 
+
 /** Validated connection facts from one config snapshot. */
 export function resolveOptions(config = {}) {
   const streamIdleTimeoutMs = config.streamIdleTimeoutMs ?? 300000;
@@ -50,18 +56,18 @@ export function loginHint(state) {
 }
 
 export function apply(ctx, config = {}) {
-  let current = () => config, lastRaw, lastGood;
+  // The TUI renders this route's own page, so Settings must not generate a form for it.
+  ctx.inject(["settings"], settingsCtx => {
+    settingsCtx.effect(() => settingsCtx.settings.configure({ auto: false }, ctx.fiber));
+  });
+  let lastGood;
   const options = () => {
-    const raw = current();
-    if (raw === lastRaw && lastGood !== undefined) return lastGood;
     try {
-      lastGood = resolveOptions(raw);
-      lastRaw = raw;
+      lastGood = resolveOptions(plainConfig(config));
       return lastGood;
     } catch (error) {
       if (lastGood === undefined) throw error;
-      lastRaw = raw;
-      ctx.logger.error(name + ": keeping the last good configuration after an invalid settings section");
+      ctx.logger.error(name + ": keeping the last good configuration after an invalid edit");
       return lastGood;
     }
   };
@@ -89,19 +95,17 @@ export function apply(ctx, config = {}) {
     await ensureGrokModels({ home, token, version: options().clientVersion });
   };
   const adapter = new GrokAdapter({ options, ensureModels, resolveToken });
-  ctx.llm.registerConfigurableProviders([{ provider: PROVIDER, displayName: "Grok", settingsNs: NS, settingsPath: [] }]);
+  ctx.llm.registerConfigurableProviders([{ provider: PROVIDER, displayName: "Grok", settingsNs: ctx.fiber.entry?.options.id ?? NS, settingsPath: [] }]);
   const registration = ctx.llm.registerAdapter([PROVIDER], adapter);
-  let registeredPolicy = JSON.stringify(options().retryPolicy);
-  ctx.inject(["settings"], settingsCtx => {
-    settingsCtx.settings.installSection(ctx, NS, Config, config, {
-      setSource: source => { current = source; },
-      onChange: () => {
-        const policy = JSON.stringify(options().retryPolicy);
-        if (policy === registeredPolicy) return;
-        registration.replace([PROVIDER]);
-        registeredPolicy = policy;
-      },
-    });
+  // The retry policy is captured at registration, and a reference carries no change
+  // callback: re-register the route when an edit lands on a different policy.
+  let registeredPolicy = options().retryPolicy;
+  ctx.on("loader/volatile-update", () => {
+    let policy;
+    try { policy = options().retryPolicy; } catch (error) { ctx.logger.warn(error); return; }
+    if (deepEqualJson(policy, registeredPolicy)) return;
+    registration.replace([PROVIDER]);
+    registeredPolicy = policy;
   });
   // Warm the catalog and the weekly window for a user who already ran `grok login`, then keep
   // the window fresh at the interval the official CLI itself watches (subscription_watch_interval_secs).

package/plugins/memory/index.mjs

@@ -48,7 +48,7 @@ export function apply(ctx, options = {}) {
       await chargeTo(live.has(lastSession) ? lastSession : undefined, 'memory', async () => {
         for await (const chunk of ctx.llm.stream({
           ...target, ...(reasoningEffort ? { reasoningEffort } : {}),
-          system, messages: [createUserMessage({ content: [{ type: 'text', text: JSON.stringify(input) }], source: { kind: 'plugin', plugin: name } })],
+          system, messages: [createUserMessage({ content: [{ type: 'text', text: JSON.stringify(input) }], source: { kind: name } })],
           maxTokens: 12000, signal: deadline,
         })) {
           deadline.throwIfAborted(); assembler.push(chunk);

package/plugins/message-source/kind.mjs

@@ -0,0 +1,20 @@
+/**
+ * Producer identity of one message source.
+ *
+ * DSH 0.1.7 retired the shared `plugin` kind: every producer now declares its own
+ * `kind`, and DSCODE's plugins name themselves the same way. Durable history carries two
+ * older shapes — the raw `{ kind: 'plugin', plugin: '<producer>' }` of a session written
+ * before the upgrade, and the `plugin:<producer>` kind the session format's v3-to-v4
+ * migration writes for a producer it does not know — so every reader of history resolves
+ * all three through this one function.
+ *
+ * @param source - a message source from any release.
+ * @returns the producing subsystem's name, or `''` when the source names none.
+ */
+export function producerKind(source) {
+  if (source === null || typeof source !== 'object') return '';
+  const { kind, plugin } = source;
+  if (kind === 'plugin') return typeof plugin === 'string' ? plugin : '';
+  if (typeof kind !== 'string') return '';
+  return kind.startsWith('plugin:') ? kind.slice('plugin:'.length) : kind;
+}

package/plugins/openrouter/adapter.mjs

@@ -1,4 +1,4 @@
-import { LlmAdapter, LlmError, ReasoningEffortId, attributionHeaders, contentHasImage, offloadRequestImagesWithPolicy, offloadedImageText } from '@deepseek-ai/dsh-llm';
+import { IMAGE_OFFLOAD_REQUIRED_CODE, LlmAdapter, LlmError, ReasoningEffortId, attributionHeaders, contentHasImage, offloadedImageText, projectOffloadedImages, requiredImageOffload } from '@deepseek-ai/dsh-llm';
 import { listOpenRouterModels, openRouterModel } from './models.mjs';
 import { PROVIDER, effortInfo, errorCode, errorMessage, modelReasoning, requestBody, retryAfterMs, sseData, translate } from './wire.mjs';
 
@@ -157,22 +157,38 @@ export class OpenRouterAdapter extends LlmAdapter {
     }
   }
 
-  /** Read request versions of every image, oldest beyond the byte budget replaced by text first. */
+  /**
+   * Read request versions of every retained image.
+   *
+   * DSH 0.1.7 made the offloaded set a durable surface fact: a route projects what the
+   * surface already offloaded into text and reports how much more must go with
+   * `IMAGE_OFFLOAD_REQUIRED`, instead of dropping the oldest occurrences itself. The
+   * `compaction-image-offload` executor records that choice and retries, so the decision
+   * survives a route change, resume and replay rather than being remade per request.
+   */
   async prepareImages(options, entry, connection, signal) {
-    if (!options.messages.some(message => contentHasImage(message.content))) return undefined;
-    if (!entry?.inputModalities?.includes('image')) throw new LlmError(`OpenRouter model "${options.model}" does not accept image input.`, 'UNSUPPORTED_CONTENT');
     const attachments = this.config.resolveAttachments?.();
+    const access = ref => (attachments === undefined ? undefined : this.config.resolveImageAccess?.(attachments, ref));
+    const messages = projectOffloadedImages(options.messages, ref => offloadedImageText(ref, access(ref)));
+    const withImages = messages.some(message => contentHasImage(message.content));
+    if (!withImages) return messages === options.messages ? undefined : { options: { ...options, messages: [...messages] }, versions: new Map(), access };
+    if (!entry?.inputModalities?.includes('image')) throw new LlmError(`OpenRouter model "${options.model}" does not accept image input.`, 'UNSUPPORTED_CONTENT');
     if (attachments === undefined) throw new LlmError('OpenRouter image input requires the durable attachment service.', 'UNSUPPORTED_CONTENT');
-    const access = ref => this.config.resolveImageAccess?.(attachments, ref);
-    const bounded = policyBytes => offloadRequestImagesWithPolicy(policyBytes.messages, {
-      representation: 'base64', maxBytes: connection.maxRequestImageBytes, byteQuantum: 1,
-      byteLength: policyBytes.byteLength, placeholder: ref => offloadedImageText(ref, access(ref)),
-    });
-    const estimated = bounded({ messages: options.messages, byteLength: ref => Math.min(ref.bytes, IMAGE_POLICY.maxBytes) });
     const refs = new Map();
-    for (const message of estimated) collectImages(message.content, refs);
+    for (const message of messages) collectImages(message.content, refs);
     const versions = new Map(await Promise.all([...refs.values()].map(async ref => [ref.attachmentId, await attachments.readImageRequest(ref, IMAGE_POLICY, signal)])));
-    const exact = bounded({ messages: estimated, byteLength: ref => versions.get(ref.attachmentId).bytes });
-    return { options: { ...options, messages: [...exact] }, versions, access };
+    const offloadImages = requiredImageOffload(
+      messages,
+      { representation: 'base64', maxBytes: connection.maxRequestImageBytes, byteQuantum: 1 },
+      block => versions.get(block.attachment.attachmentId).bytes,
+    );
+    if (offloadImages > 0) {
+      throw new LlmError(
+        `OpenRouter request images exceed ${connection.maxRequestImageBytes} bytes; ${offloadImages} more oldest occurrence(s) must be offloaded.`,
+        IMAGE_OFFLOAD_REQUIRED_CODE,
+        { offloadImages },
+      );
+    }
+    return { options: { ...options, messages: [...messages] }, versions, access };
   }
 }

package/plugins/openrouter/index.mjs

@@ -1,28 +1,34 @@
 import z from '@deepseek-ai/schemastery';
 import { LlmError, RetryPolicySchema, assertUsableApiKey, resolveImageAttachmentAccess, resolveRetryPolicy } from '@deepseek-ai/dsh-llm';
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
+import { deepEqualJson } from '@deepseek-ai/dsh-util-values';
+import { plainConfig } from '../cordis-config/plain.mjs';
 import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment';
 import { OpenRouterAdapter, PROVIDER } from './adapter.mjs';
 import { ensureOpenRouterModels } from './models.mjs';
 import { OpenRouterSearchProvider, RoutedSearchProvider } from './search.mjs';
 
 // The `openrouter` route: DSCODE's own OpenRouter adapter over its live model
-// listing, configured by the `llm-openrouter` settings section, plus web search
-// that follows the session's route.
+// listing, configured by this entry's own profile row, plus web search that
+// follows the session's route.
 export const name = 'dscode-openrouter';
 export const inject = ['llm'];
 const NS = 'llm-openrouter';
 const DEFAULT_BASE_URL = 'https://openrouter.ai/api/v1';
 
+// DSH 0.1.7 replaced settings sections with volatile configuration: a field marked
+// `.volatile()` reaches the plugin as a reference the Settings form and a profile edit
+// both write, so each read below sees the current value without a change callback.
 export const Config = z.object({
-  apiKeyEnv: z.string().role('credential-ref').default('OPENROUTER_API_KEY'),
-  baseURL: z.string().default(DEFAULT_BASE_URL),
-  streamIdleTimeoutMs: z.number().min(1).default(300000),
-  maxRequestImageBytes: z.number().step(1).min(1).default(20 * 1024 * 1024),
-  searchModel: z.string().default('deepseek/deepseek-v4-flash'),
-  retryPolicy: RetryPolicySchema,
+  apiKeyEnv: z.string().role('credential-ref').default('OPENROUTER_API_KEY').volatile(),
+  baseURL: z.string().default(DEFAULT_BASE_URL).volatile(),
+  streamIdleTimeoutMs: z.number().min(1).default(300000).volatile(),
+  maxRequestImageBytes: z.number().step(1).min(1).default(20 * 1024 * 1024).volatile(),
+  searchModel: z.string().default('deepseek/deepseek-v4-flash').volatile(),
+  retryPolicy: RetryPolicySchema.volatile(),
 });
 
+
 /** Validated connection facts from one config snapshot. */
 export function resolveOptions(config = {}) {
   const streamIdleTimeoutMs = config.streamIdleTimeoutMs ?? 300000;
@@ -40,18 +46,18 @@ export function resolveOptions(config = {}) {
 }
 
 export function apply(ctx, config = {}) {
-  let current = () => config, lastRaw, lastGood;
+  // The TUI renders this route's own page, so Settings must not generate a form for it.
+  ctx.inject(['settings'], settingsCtx => {
+    settingsCtx.effect(() => settingsCtx.settings.configure({ auto: false }, ctx.fiber));
+  });
+  let lastGood;
   const options = () => {
-    const raw = current();
-    if (raw === lastRaw && lastGood !== undefined) return lastGood;
     try {
-      lastGood = resolveOptions(raw);
-      lastRaw = raw;
+      lastGood = resolveOptions(plainConfig(config));
       return lastGood;
     } catch (error) {
       if (lastGood === undefined) throw error;
-      lastRaw = raw;
-      ctx.logger.error(`${name}: keeping the last good configuration after an invalid settings section`);
+      ctx.logger.error(`${name}: keeping the last good configuration after an invalid edit`);
       ctx.logger.error(error);
       return lastGood;
     }
@@ -75,20 +81,17 @@ export function apply(ctx, config = {}) {
     resolveAttachments: () => ctx.get('attachments'),
     resolveImageAccess: (attachments, ref) => resolveImageAttachmentAccess(attachments, hostPath => ctx.get('fs')?.processPathFromHostPath(hostPath), ref),
   });
-  ctx.llm.registerConfigurableProviders([{ provider: PROVIDER, displayName: 'OpenRouter', settingsNs: NS, settingsPath: [] }]);
+  ctx.llm.registerConfigurableProviders([{ provider: PROVIDER, displayName: 'OpenRouter', settingsNs: ctx.fiber.entry?.options.id ?? NS, settingsPath: [] }]);
   const registration = ctx.llm.registerAdapter([PROVIDER], adapter);
-  let registeredPolicy = JSON.stringify(options().retryPolicy);
-  ctx.inject(['settings'], settingsCtx => {
-    settingsCtx.settings.installSection(ctx, NS, Config, config, {
-      setSource: source => { current = source; },
-      // The retry policy is captured at registration: re-register the route when it changes.
-      onChange: () => {
-        const policy = JSON.stringify(options().retryPolicy);
-        if (policy === registeredPolicy) return;
-        registration.replace([PROVIDER]);
-        registeredPolicy = policy;
-      },
-    });
+  // The retry policy is captured at registration, and a reference carries no change
+  // callback: re-register the route when an edit lands on a different policy.
+  let registeredPolicy = options().retryPolicy;
+  ctx.on('loader/volatile-update', () => {
+    let policy;
+    try { policy = options().retryPolicy; } catch (error) { ctx.logger.warn(error); return; }
+    if (deepEqualJson(policy, registeredPolicy)) return;
+    registration.replace([PROVIDER]);
+    registeredPolicy = policy;
   });
   ctx.inject(['web'], webCtx => {
     const openrouter = new OpenRouterSearchProvider(() => {

package/plugins/session-bridge/communication.mjs

@@ -1,9 +1,10 @@
 import { createUserMessage, freezeMessage } from '@deepseek-ai/dsh-llm';
 import { Mailbox, fail } from './mailbox.mjs';
+import { producerKind } from '../message-source/kind.mjs';
 import { discover, request as socketRequest } from './client.mjs';
 
 const plugin = 'dscode-session-bridge';
-export const communicationId = m => m?.source?.plugin === plugin ? m.source.communicationId : undefined;
+export const communicationId = m => producerKind(m?.source) === plugin ? m.source.communicationId : undefined;
 export const isHuman = m => ['user', 'human'].includes(m?.source?.kind);
 const eligible = a => a?.session.header.agentPreset === 'dscode' || a?.session.header.origin === 'subagent';
 
@@ -17,7 +18,9 @@ export class CommunicationService {
     this.pending = new Set();
     this.closed = false;
     this.disposers = [
-      ctx.on('agent/session-start', ({ agent }) => this.start(agent)),
+      // DSH 0.1.7 retired `agent/session-start`: `agent/created` is awaited at the same
+      // point, once the session is entered and announced.
+      ctx.on('agent/created', ({ agent }) => this.start(agent)),
       ctx.on('agent/pre-step', (payload, next) => this.preStep(payload, next)),
       ctx.on('session/event', (session, event) => this.observe(session, event)),
       ctx.on('agent/inbox/discarded', ({ agent, message }) => {
@@ -102,7 +105,7 @@ export class CommunicationService {
     // Identity must survive retries even when the prior native inbox insertion did not persist.
     return freezeMessage({ ...createUserMessage({ content: [{ type: 'text', text:
       `[External source: ${e.from.kind === 'session' ? `session:${e.from.sessionId}` : e.from.source}] [${e.kind}/${e.mode}]\nMessage ID: ${e.messageId}${e.inReplyTo ? `; reply to: ${e.inReplyTo}` : ''}\n${e.text}` }],
-      source: { kind: 'plugin', plugin, form: 'relay', communicationId: e.messageId, requestId: e.idempotencyKey,
+      source: { kind: plugin, form: 'relay', communicationId: e.messageId, requestId: e.idempotencyKey,
         label: e.from.kind === 'session' ? `session:${e.from.sessionId}` : e.from.source, mode: e.mode, composedAt: e.createdAt } }), id: e.messageId });
   }
   async confirm(state) {

package/plugins/session-bridge/server.mjs

@@ -5,6 +5,7 @@ import { randomUUID, createHash } from 'node:crypto';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { normalizeSessionTitle } from '@deepseek-ai/dsh-session-title';
 import { ensureSocketDirectory } from './paths.mjs';
+import { producerKind } from '../message-source/kind.mjs';
 
 export const BRIDGE_SOURCE = 'dscode-session-bridge';
 const MAX_REQUEST = 128 * 1024, MAX_BUFFER = 8 * 1024 * 1024;
@@ -51,7 +52,7 @@ export class SessionBridge {
     if (!cache) { cache = { seq: 0, values: new Map() }; this.receipts.set(session, cache); }
     for (const event of session.snapshotEvents(cache.seq)) {
       const messages = event.type === 'agent/inbox/spliced' ? event.data.inserted : event.type === 'user/message' ? [event.data] : [];
-      for (const message of messages) if (message.source.kind === 'plugin' && message.source.plugin === BRIDGE_SOURCE && message.source.requestId) {
+      for (const message of messages) if (producerKind(message.source) === BRIDGE_SOURCE && message.source.requestId) {
         cache.values.set(message.source.requestId, { digest: message.source.digest, messageId: message.id });
       }
     }
@@ -82,7 +83,7 @@ export class SessionBridge {
     let messageId = previous?.messageId;
     if (!previous) {
       const message = createUserMessage({ content: [{ type: 'text', text: `[External source: ${source}]\n${text}` }],
-        source: { kind: 'plugin', plugin: BRIDGE_SOURCE, form: 'relay', requestId, digest, label: source, mode } });
+        source: { kind: BRIDGE_SOURCE, form: 'relay', requestId, digest, label: source, mode } });
       // Explicit naming uses the native title service, including sanitization,
       // persistence, UI events and cancellation of stale automatic title work.
       // A duplicate request must never undo a newer title.

package/plugins/session-bridge/tasks.mjs

@@ -21,6 +21,8 @@ const MAX_WAITING_REQUESTS = 16
 const MAX_PREVIEW_CHARS = 72
 
 /** The plugin name the session bridge stamps on its relayed messages. */
+import { producerKind } from '../message-source/kind.mjs'
+
 const BRIDGE_PLUGIN = 'dscode-session-bridge'
 
 /** Tool names that address another session. */
@@ -67,7 +69,7 @@ function relayFields(data) {
   if (data === null || typeof data !== 'object') return undefined
   const source = data.source
   if (source === null || typeof source !== 'object') return undefined
-  if (source.kind !== 'plugin' || source.plugin !== BRIDGE_PLUGIN || source.form !== 'relay') return undefined
+  if (producerKind(source) !== BRIDGE_PLUGIN || source.form !== 'relay') return undefined
   const label = typeof source.label === 'string' && source.label !== '' ? source.label : undefined
   const id = typeof source.communicationId === 'string' && source.communicationId !== '' ? source.communicationId : undefined
   if (label === undefined && id === undefined) return undefined

package/plugins/session-cards/index.mjs

@@ -16,7 +16,7 @@ export function apply(ctx, config = {}) {
     const reasoningEffort = await effortFor(ctx.llm, base, 'low', signal);
     await chargeTo(sessionId, 'session-card', async () => {
       for await (const chunk of ctx.llm.stream({ ...base, ...(reasoningEffort ? { reasoningEffort } : {}), system: TOPIC_PROMPT,
-        messages: [createUserMessage({ content: [{ type: 'text', text: JSON.stringify(input) }], source: { kind: 'plugin', plugin: name } })],
+        messages: [createUserMessage({ content: [{ type: 'text', text: JSON.stringify(input) }], source: { kind: name } })],
         maxTokens: 2000, signal })) {
         signal.throwIfAborted(); assembler.push(chunk);
         if (chunk.type === 'finish') finished = true;

package/plugins/time-marks/index.mjs

@@ -12,6 +12,7 @@
 import z from '@deepseek-ai/schemastery';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { arrivalMark, resolveTimeZone, turnEndMark } from './marks.mjs';
+import { producerKind } from '../message-source/kind.mjs';
 export const name = 'dscode-time-marks';
 export const Config = z.object({
   /** Fallback display zone; empty uses the host zone. */
@@ -42,7 +43,7 @@ export function apply(ctx, config = {}) {
     for (const message of payload.messages) {
       // Marks are injected context, never an inbox arrival; skipping our own
       // producer keeps a future delivery path from marking itself.
-      if (message.source?.plugin === name) continue;
+      if (producerKind(message.source) === name) continue;
       const line = arrivalMark(message, at, timeZone);
       if (line !== null && lines.length < MARK_LIMIT) lines.push(line);
     }
@@ -60,7 +61,7 @@ export function apply(ctx, config = {}) {
       // the prompt there, not this mark.
       messages: [createUserMessage({
         content: [{ type: 'text', text: lines.join('\n') }],
-        source: { kind: 'plugin', plugin: name, form: 'snapshot' },
+        source: { kind: name, form: 'snapshot' },
       }), ...decision.messages],
     };
   }, { prepend: true });

package/plugins/time-marks/marks.mjs

@@ -7,6 +7,8 @@
  * @module dscode-time-marks/marks
  */
 
+import { producerKind } from '../message-source/kind.mjs'
+
 /** Shortest queue wait worth naming; below it the message simply arrived. */
 const WAIT_FLOOR_MS = 1_000
 
@@ -108,15 +110,14 @@ export function elapsedText(ms) {
  * @returns the attribution clause.
  */
 export function describeSource(source) {
-  const kind = plain(source?.kind)
-  if (kind === 'user') return 'user message'
-  if (kind !== 'plugin') return kind === '' ? 'message' : `message via ${kind}`
-  if (source.form === 'relay') {
+  const producer = producerKind(source)
+  if (producer === 'user') return 'user message'
+  if (source?.form === 'relay') {
     const mode = plain(source.mode) || 'queue'
     const label = plain(source.label) || 'another session'
     return `${mode} relay from ${label}`
   }
-  return `message from ${plain(source.plugin) || 'a plugin'}`
+  return producer === '' ? 'message' : `message from ${producer}`
 }
 
 /**

package/plugins/triggers/config.mjs

@@ -34,7 +34,7 @@ export const DEFAULTS = Object.freeze({
 });
 
 /** Permission presets an unattended run may use; `ask` can never complete. */
-const UNATTENDED_PERMISSIONS = Object.freeze(['auto', 'workspace-write', 'read-only', 'danger-full-access']);
+const UNATTENDED_PERMISSIONS = Object.freeze(['auto-review', 'auto', 'workspace-write', 'read-only', 'danger-full-access']);
 
 const ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/u;
 

package/plugins/triggers/tools.mjs

@@ -12,7 +12,7 @@ export function mutationProblem(ctx, agent) {
   const plan = ctx.get('planMode')?.get(agent);
   if (plan?.active || plan?.pending) return 'Schedule management is unavailable in plan mode';
   const permission = ctx.permissionPresets.current(agent.session);
-  if (!['auto', 'ask', 'workspace-write', 'danger-full-access'].includes(permission)) return 'Schedule management requires a writable permission preset';
+  if (!['auto-review', 'auto', 'ask', 'workspace-write', 'danger-full-access'].includes(permission)) return 'Schedule management requires a writable permission preset';
 }
 
 export function registerTriggerTools(ctx, { home, ...deps }) {

package/plugins/tui-tools/doctor.mjs

@@ -131,7 +131,7 @@ export async function analyzeDoctorEvidence(ctx, evidence, route, signal, { mode
     const reasoningEffort = await effortFor(ctx.llm, route, 'low', deadline);
     await chargeTo(sessionId, 'doctor', async () => {
       for await (const chunk of ctx.llm.stream({ provider: route.provider, model: route.model, ...(reasoningEffort ? { reasoningEffort } : {}), maxTokens: 4096, system: SYSTEM,
-        messages: [createUserMessage({ content: [{ type: 'text', text: JSON.stringify(evidence) }], source: { kind: 'plugin', plugin: 'dscode-doctor' } })], signal: deadline })) {
+        messages: [createUserMessage({ content: [{ type: 'text', text: JSON.stringify(evidence) }], source: { kind: 'dscode-doctor' } })], signal: deadline })) {
         deadline.throwIfAborted(); assembler.push(chunk);
         if (chunk.type === 'finish') finished = true;
       }