dsh-aris-panel 0.1.0

package/dsh/cordis.patch.yml

@@ -0,0 +1,44 @@
+# ARIS bundle layer for DeepSeek Harness.
+#
+# Applied after the profile's surface bundle. Patch config replacement is
+# whole-value, so rows that adjust shipped configuration restate every field
+# they need.
+
+# ARIS review runs on the stronger executor.
+- id: agent-default-model
+  config:
+    provider: deepseek-official
+    model: deepseek-v4-pro
+
+- insert:
+    # Skill corpus, ARIS_REPO, and the Codex threadId projection.
+    - id: aris-skills
+      name: 'dsh-aris'
+
+    # Optional: apply ARIS's scope limits to the executor as well as the
+    # reviewer. Off by default — it spends tokens on every request, and the
+    # reviewer side is already covered by the skills. Flip to enable.
+    - id: aris-scope-limits
+      name: 'dsh-aris/scope-limits'
+      disabled: true
+
+    # The independent reviewer. Model and reasoning effort come from the host
+    # Codex installation (~/.codex/config.toml) — that file is the reviewer
+    # posture contract, and dsh deliberately does not override it.
+    - id: aris-codex
+      name: '@deepseek-ai/dsh-mcp-client'
+      config:
+        transport: stdio
+        serverName: codex
+        command: codex
+        args: [mcp-server]
+        # Pinned to a directory that outlives the run. Inheriting the Harness's
+        # launch directory makes every review depend on it still existing:
+        # remove or rename it and Codex fails to load its own configuration,
+        # which ARIS survives by degrading to a transport that cannot attest
+        # reviewer identity. Review prompts address artifacts absolutely.
+        cwd: !!js process.env.HOME
+        # dsh defaults to 60s and Codex's progress notifications do not extend it.
+        # 20 minutes is ARIS's own threshold for calling a review hung.
+        toolCallTimeoutMs: 1200000
+        failOnStartupError: true

package/dsh/index.mjs

@@ -0,0 +1,76 @@
+/**
+ * ARIS bundle adapter for DeepSeek Harness.
+ *
+ * Four effects, none of which the declarative layer can express:
+ *   1. mount the packaged skill corpus from a path only this module can resolve
+ *   2. publish the package root as ARIS_REPO so skills reach their helper scripts
+ *   3. project Codex's threadId into model-visible content so codex-reply works
+ *   4. serve the run-status view its read-only projection of the loop artifacts
+ */
+
+import { fileURLToPath } from 'node:url'
+import * as skillFilesystem from '@deepseek-ai/dsh-skill-filesystem'
+import { registerRunStatus } from './run-status.mjs'
+import { registerWorkbench } from './workbench.mjs'
+
+export const name = 'aris-skills'
+export const inject = ['skills', 'tools']
+
+/** Package root; identical in a git checkout and under node_modules. */
+const PACKAGE_ROOT = fileURLToPath(new URL('../', import.meta.url))
+const SKILL_ROOT = fileURLToPath(new URL('../skills/', import.meta.url))
+
+/** Codex MCP tools whose reply carries a continuation threadId. */
+const CODEX_TOOLS = new Set(['mcp__codex__codex', 'mcp__codex__codex-reply'])
+
+export async function apply(ctx) {
+  // ARIS skills resolve shared helpers through $ARIS_REPO/tools
+  // (skills/shared-references/integration-contract.md). An operator-set value wins.
+  ctx.effect(() => {
+    const inherited = process.env.ARIS_REPO
+    if (inherited === undefined) process.env.ARIS_REPO = PACKAGE_ROOT
+    return () => {
+      if (inherited === undefined && process.env.ARIS_REPO === PACKAGE_ROOT) {
+        delete process.env.ARIS_REPO
+      }
+    }
+  }, 'ARIS package root')
+
+  // Rank 600 (bundledSkillDir): a project or user skill of the same name wins.
+  await ctx.plugin(skillFilesystem, {
+    providerName: 'aris',
+    includeDefaultRoots: false,
+    bundledSkillDir: SKILL_ROOT,
+    watch: false,
+  })
+
+  registerRunStatus(ctx)
+  registerWorkbench(ctx)
+
+  // dsh renders only an MCP result's `content` to the model, while Codex returns
+  // threadId solely in `structuredContent`. Without this the model cannot continue
+  // a review thread, which the hard-tier Debate Protocol requires.
+  ctx.on('tools/post-execute', async (exec, result, next) => {
+    const decision = await next()
+    if (!CODEX_TOOLS.has(exec.name)) return decision
+    if (result.isError || decision.kind !== 'accept') return decision
+    if (Object.hasOwn(decision, 'value')) return decision
+
+    const threadId = result.value?.structuredContent?.threadId
+    if (typeof threadId !== 'string') return decision
+
+    // Prefixed and labelled: a spilled or pruned result keeps its head, and the
+    // reviewer's own prose is never mistaken for harness metadata. The trailing
+    // blank line matters — text blocks reach the model joined with no separator.
+    return {
+      ...decision,
+      content: [
+        {
+          type: 'text',
+          text: `Codex continuation metadata (not part of the reviewer response): threadId=${threadId}\n\n`,
+        },
+        ...decision.content ?? result.content,
+      ],
+    }
+  })
+}

package/dsh/run-status.mjs

@@ -0,0 +1,182 @@
+/**
+ * Host half of the ARIS run-status view: one read-only RPC that projects the
+ * loop's durable artifacts for the browser tab.
+ *
+ * The artifacts stay canonical. Nothing here caches, writes, or interprets
+ * them beyond parsing REVIEW_STATE.json and stat-ing the files ARIS maintains.
+ */
+
+import { readdir, readFile, stat } from 'node:fs/promises'
+import { isAbsolute, join } from 'node:path'
+
+/** Channel the browser half calls. */
+export const ARIS_RPC_CHANNEL = '/aris'
+
+/**
+ * Artifacts every auto-review-loop run maintains, relative to the workspace.
+ * Stage outputs (plan, draft) vary by workflow and are deliberately absent.
+ */
+const ARTIFACTS = [
+  'review-stage/REVIEW_STATE.json',
+  'review-stage/AUTO_REVIEW.md',
+  'review-stage/REVIEWER_MEMORY.md',
+  'review-stage/ACQUITTAL_LOG.jsonl',
+]
+
+/** Fields the view reads; anything else in the state file is passed through untouched. */
+const STATE_FILE = 'review-stage/REVIEW_STATE.json'
+const REVIEW_LOG = 'review-stage/AUTO_REVIEW.md'
+
+/**
+ * The latest round's ranked criticisms, verbatim.
+ *
+ * Score and verdict already come from the state file, so only the criticisms
+ * are lifted — they are what explains why the loop continued or stopped.
+ * A log that does not carry the block yields nothing rather than a guess.
+ *
+ * @returns the criticism lines without their numbering, or undefined.
+ */
+async function readCriticisms(workspace) {
+  let text
+  try {
+    text = await readFile(join(workspace, REVIEW_LOG), 'utf8')
+  } catch {
+    return undefined
+  }
+  const lines = text.split('\n')
+  let start = -1
+  for (const [index, line] of lines.entries()) {
+    if (/^\s*-\s*Key criticisms/i.test(line)) start = index
+  }
+  if (start === -1) return undefined
+  const items = []
+  for (const line of lines.slice(start + 1)) {
+    const item = /^\s+\d+\.\s+(.*\S)\s*$/.exec(line)
+    if (item === null) break
+    items.push(item[1])
+  }
+  return items.length > 0 ? items : undefined
+}
+
+/** @returns `{exists, mtime, size}` for one workspace-relative path. */
+async function describe(workspace, relative) {
+  try {
+    const info = await stat(join(workspace, relative))
+    return { path: relative, exists: true, mtime: info.mtimeMs, size: info.size }
+  } catch {
+    return { path: relative, exists: false }
+  }
+}
+
+/** @returns the parsed state file, or an error string the view shows verbatim. */
+async function readState(workspace) {
+  let text
+  try {
+    text = await readFile(join(workspace, STATE_FILE), 'utf8')
+  } catch {
+    return { state: undefined, stateError: undefined }
+  }
+  try {
+    const parsed = JSON.parse(text)
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+      return { state: undefined, stateError: `${STATE_FILE} is not a JSON object` }
+    }
+    return { state: parsed, stateError: undefined }
+  } catch (error) {
+    return { state: undefined, stateError: `${STATE_FILE} is not valid JSON: ${error.message}` }
+  }
+}
+
+/** Where `tools/run_state.py` persists a resumable pipeline run. */
+const RUNS_DIR = '.aris/runs'
+
+/**
+ * Read the most recently updated pipeline run, if any.
+ *
+ * A phase's `status` separates what the executor claims from what an
+ * independent reviewer accepted: only `accept()` writes `accepted`, and only
+ * with a recorded reviewer and verdict id. A `done` phase that never reached
+ * `accepted` is an unmet acceptance obligation, and the view says so.
+ *
+ * @returns the run, or undefined when this workspace has no resumable run.
+ */
+async function readPipeline(workspace) {
+  let names
+  try {
+    names = await readdir(join(workspace, RUNS_DIR))
+  } catch {
+    return undefined
+  }
+  let newest
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue
+    const path = join(workspace, RUNS_DIR, name)
+    let run
+    try {
+      run = JSON.parse(await readFile(path, 'utf8'))
+    } catch {
+      continue
+    }
+    if (typeof run !== 'object' || run === null || !Array.isArray(run.phases)) continue
+    if (newest === undefined || String(run.updated ?? '') > String(newest.updated ?? '')) newest = run
+  }
+  if (newest === undefined) return undefined
+  return {
+    runId: newest.run_id,
+    updated: newest.updated,
+    executor: newest.executor_model,
+    executorFamily: newest.executor_family,
+    phases: newest.phases.map(entry => ({
+      phase: entry.phase,
+      status: entry.status,
+      artifact: entry.artifact ?? undefined,
+      reviewer: entry.reviewer ?? undefined,
+      reviewerFamily: entry.reviewer_family ?? undefined,
+      independence: entry.review_independence ?? undefined,
+      verdictId: entry.verdict_id ?? undefined,
+    })),
+  }
+}
+
+/**
+ * Register the run-status RPC when a browser connection exists.
+ * Headless compositions have no `connection`, so the channel never mounts.
+ * @param ctx - the ARIS plugin's context.
+ */
+export function registerRunStatus(ctx) {
+  ctx.inject(['connection', 'sessions'], (scoped) => {
+    scoped.effect(() => scoped.connection.rpc.handle(
+      ARIS_RPC_CHANNEL,
+      async (endpoint, payload) => {
+        if (endpoint !== 'state') {
+          return { ok: false, error: { code: 'UNKNOWN_ENDPOINT', message: `unknown ARIS endpoint "${endpoint}"` } }
+        }
+        const sessionId = typeof payload === 'object' && payload !== null ? payload.sessionId : undefined
+        if (typeof sessionId !== 'string') {
+          return { ok: false, error: { code: 'BAD_REQUEST', message: 'sessionId is required' } }
+        }
+        const workspace = scoped.sessions.get(sessionId)?.header?.cwd
+        if (typeof workspace !== 'string' || !isAbsolute(workspace)) {
+          return { ok: true, value: { workspace: undefined, artifacts: [] } }
+        }
+        const { state, stateError } = await readState(workspace)
+        const pipeline = await readPipeline(workspace)
+        const criticisms = await readCriticisms(workspace)
+        const artifacts = await Promise.all(ARTIFACTS.map(relative => describe(workspace, relative)))
+        return {
+          ok: true,
+          value: {
+            workspace,
+            ...state !== undefined ? { state } : {},
+            ...stateError !== undefined ? { stateError } : {},
+            ...pipeline !== undefined ? { pipeline } : {},
+            ...criticisms !== undefined ? { criticisms } : {},
+            artifacts,
+            readAt: Date.now(),
+          },
+        }
+      },
+      { authority: 'loopback' },
+    ), 'ARIS run-status RPC')
+  })
+}

package/dsh/scope-limits.mjs

@@ -0,0 +1,50 @@
+/**
+ * Optional executor-side scope limits.
+ *
+ * ARIS's reviewers already carry these limits — the block is embedded in the
+ * skills that produce review prompts. Nothing bounds the executor the same way,
+ * so this row offers the same contract as a system-prompt section. It is
+ * disabled by default: it costs tokens on every request, and whether an
+ * executor should be bound is a per-deployment choice.
+ *
+ * The text is read from the packaged `skills/shared-references/review-scope-limits.md`
+ * rather than copied here, so the reviewer path and this one cannot drift apart.
+ */
+
+import { readFile } from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
+
+export const name = 'aris-scope-limits'
+export const inject = ['systemPrompt']
+
+const DOCTRINE = fileURLToPath(
+  new URL('../skills/shared-references/review-scope-limits.md', import.meta.url),
+)
+
+/** Prompt order: after the harness identity and persona, with tool guidance. */
+const ORDER = 120
+
+/** Reviewer-facing framing replaced by executor-facing framing, verbatim otherwise. */
+const PREAMBLE = 'These limits bound what you PROPOSE and build, never what you look for.'
+
+/**
+ * Lift the canonical block out of the doctrine document.
+ * @returns the fenced block's body, or undefined when the document has none.
+ */
+function extractBlock(markdown) {
+  const fence = /```\n(=== SCOPE LIMITS[\s\S]*?)```/.exec(markdown)
+  return fence === null ? undefined : fence[1].trim()
+}
+
+export async function apply(ctx) {
+  const markdown = await readFile(DOCTRINE, 'utf8')
+  const block = extractBlock(markdown)
+  if (block === undefined) {
+    throw new Error(`aris-scope-limits: no SCOPE LIMITS block in ${DOCTRINE}`)
+  }
+  ctx.effect(() => ctx.systemPrompt.section({
+    name: 'aris:scope-limits',
+    order: ORDER,
+    text: `${PREAMBLE}\n\n${block}`,
+  }), 'ARIS executor scope limits')
+}

package/dsh/workbench.mjs

@@ -0,0 +1,291 @@
+/**
+ * ARIS workbench — host half.
+ *
+ * Read-only RPC projections over the ARIS artifacts for the workbench view:
+ * pipeline/review state, idea board, experiment runs, research-wiki graph,
+ * plus the packaged skill corpus and a best-effort launch (inject a prompt
+ * into a live session and wake its driver).
+ */
+
+import { readdir, readFile, stat } from 'node:fs/promises'
+import { isAbsolute, join } from 'node:path'
+
+export const WORKBENCH_RPC_CHANNEL = '/aris-wb'
+
+const WIKI_DIRS = ['papers', 'ideas', 'experiments', 'claims']
+const SKILL_ROOT = new URL('../skills/', import.meta.url)
+const TICK = String.fromCharCode(96)
+
+async function readText(workspace, rel) {
+  try { return await readFile(join(workspace, rel), 'utf8') } catch { return undefined }
+}
+
+async function readJson(workspace, rel) {
+  try { return JSON.parse(await readFile(join(workspace, rel), 'utf8')) } catch { return undefined }
+}
+
+async function statFile(workspace, rel) {
+  try {
+    const info = await stat(join(workspace, rel))
+    return { exists: true, mtime: info.mtimeMs, size: info.size }
+  } catch {
+    return { exists: false }
+  }
+}
+
+async function listDir(workspace, rel) {
+  try { return (await readdir(join(workspace, rel))).sort() } catch { return undefined }
+}
+
+function summarizeMarkdown(text, maxLines) {
+  if (text === undefined) return undefined
+  const lines = text.split(String.fromCharCode(10))
+  return { totalLines: lines.length, head: lines.slice(0, maxLines) }
+}
+
+async function readPipeline(workspace) {
+  const names = await listDir(workspace, '.aris/runs')
+  if (names === undefined) return undefined
+  let newest
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue
+    const run = await readJson(workspace, '.aris/runs/' + name)
+    if (run === undefined || typeof run !== 'object' || !Array.isArray(run.phases)) continue
+    if (newest === undefined || String(run.updated ?? '') > String(newest.updated ?? '')) newest = run
+  }
+  if (newest === undefined) return undefined
+  return {
+    runId: newest.run_id,
+    updated: newest.updated,
+    executor: newest.executor_model,
+    executorFamily: newest.executor_family,
+    phases: newest.phases.map(entry => ({
+      phase: entry.phase,
+      status: entry.status,
+      artifact: entry.artifact ?? undefined,
+      reviewer: entry.reviewer ?? undefined,
+      reviewerFamily: entry.reviewer_family ?? undefined,
+      independence: entry.review_independence ?? undefined,
+    })),
+  }
+}
+
+async function readWiki(workspace) {
+  const entities = {}
+  for (const kind of WIKI_DIRS) {
+    const names = await listDir(workspace, 'research-wiki/' + kind)
+    if (names === undefined) continue
+    const files = []
+    for (const name of names) {
+      if (!name.endsWith('.md')) continue
+      const text = await readText(workspace, 'research-wiki/' + kind + '/' + name)
+      files.push({
+        name,
+        lines: text === undefined ? 0 : text.split(String.fromCharCode(10)).length,
+        head: text === undefined ? undefined : text.split(String.fromCharCode(10)).slice(0, 8),
+      })
+    }
+    entities[kind] = files
+  }
+  const edgesText = await readText(workspace, 'research-wiki/graph/edges.jsonl')
+  const edges = []
+  if (edgesText !== undefined) {
+    for (const line of edgesText.split(String.fromCharCode(10))) {
+      const trimmed = line.trim()
+      if (trimmed === '') continue
+      try { edges.push(JSON.parse(trimmed)) } catch { edges.push({ raw: trimmed }) }
+    }
+  }
+  const extras = {}
+  for (const rel of ['index.md', 'query_pack.md', 'gap_map.md', 'log.md']) {
+    extras[rel] = await statFile(workspace, 'research-wiki/' + rel)
+  }
+  return { entities, edges: edges.slice(0, 300), edgeCount: edges.length, extras }
+}
+
+async function readIdeaBoard(workspace) {
+  const board = {}
+  for (const rel of ['IDEA_REPORT.md', 'idea-stage/IDEA_REPORT.md']) {
+    const text = await readText(workspace, rel)
+    if (text !== undefined) board[rel] = summarizeMarkdown(text, 40)
+  }
+  for (const rel of ['refine-logs/FINAL_PROPOSAL.md', 'refine-logs/EXPERIMENT_PLAN.md', 'refine-logs/REFINE_LOOP.md']) {
+    const text = await readText(workspace, rel)
+    if (text !== undefined) board[rel] = summarizeMarkdown(text, 30)
+  }
+  board.refineLogsDir = await listDir(workspace, 'refine-logs')
+  return board
+}
+
+async function readExperiments(workspace) {
+  const runs = []
+  const names = await listDir(workspace, '.aris/runs')
+  if (names !== undefined) {
+    for (const name of names) {
+      if (!name.endsWith('.json')) continue
+      const run = await readJson(workspace, '.aris/runs/' + name)
+      if (run === undefined) continue
+      runs.push({
+        name,
+        runId: run.run_id,
+        updated: run.updated,
+        executor: run.executor_model,
+        phases: Array.isArray(run.phases) ? run.phases.map(p => ({ phase: p.phase, status: p.status })) : undefined,
+      })
+    }
+  }
+  const wikiExps = []
+  const expNames = await listDir(workspace, 'research-wiki/experiments')
+  if (expNames !== undefined) {
+    for (const n of expNames) if (n.endsWith('.md')) wikiExps.push(n)
+  }
+  return { runs: runs.slice(0, 20), wikiExperiments: wikiExps }
+}
+
+async function readSkillMeta(name) {
+  try {
+    const text = await readFile(new URL(name + '/SKILL.md', SKILL_ROOT), 'utf8')
+    const m = /^---\n([\s\S]*?)\n---/.exec(text)
+    if (!m) return { name }
+    const out = { name }
+    for (const line of m[1].split(String.fromCharCode(10))) {
+      const mm = /^([a-zA-Z0-9-]+):\s*(.*)$/.exec(line)
+      if (!mm) continue
+      const key = mm[1] === 'argument-hint' ? 'argumentHint' : mm[1]
+      out[key] = mm[2].trim().replace(/^\"|\"$/g, '')
+    }
+    return out
+  } catch {
+    return { name }
+  }
+}
+
+async function readSkills() {
+  const names = []
+  try {
+    const entries = await readdir(SKILL_ROOT)
+    for (const name of entries) {
+      if (name.startsWith('.')) continue
+      try {
+        const info = await stat(new URL(name + '/SKILL.md', SKILL_ROOT))
+        if (info.isFile()) names.push(name)
+      } catch { /* not a skill dir */ }
+    }
+  } catch { /* no skills */ }
+  names.sort()
+  const skills = []
+  for (const name of names) skills.push(await readSkillMeta(name))
+  return skills
+}
+
+export function registerWorkbench(ctx) {
+  ctx.inject(['connection', 'sessions', 'agents'], (scoped) => {
+    scoped.effect(() => scoped.connection.rpc.handle(
+      WORKBENCH_RPC_CHANNEL,
+      async (endpoint, payload) => {
+        if (endpoint === 'sessions') {
+          try {
+            const list = scoped.sessions.list().map(s => ({ id: s.id, cwd: s.header?.cwd ?? undefined }))
+            return { ok: true, value: { sessions: list } }
+          } catch (error) {
+            return { ok: false, error: { code: 'internal', message: String(error && error.message || error), details: {} } }
+          }
+        }
+        if (endpoint === 'skills') {
+          try {
+            const skills = await readSkills()
+            return { ok: true, value: { skills: skills } }
+          } catch (error) {
+            console.error('[aris-wb] skills failed:', error)
+            return { ok: false, error: { code: 'internal', message: String(error && error.message || error), details: {} } }
+          }
+        }
+        const sessionId = typeof payload === 'object' && payload !== null ? payload.sessionId : undefined
+        if (typeof sessionId !== 'string') {
+          return { ok: false, error: { code: 'bad-request', message: 'sessionId is required', details: {} } }
+        }
+        const workspace = scoped.sessions.get(sessionId)?.header?.cwd
+        if (typeof workspace !== 'string' || !isAbsolute(workspace)) {
+          return { ok: true, value: { workspace: undefined } }
+        }
+        try {
+          switch (endpoint) {
+            case 'overview': {
+              const state = await readJson(workspace, 'review-stage/REVIEW_STATE.json')
+              const pipeline = await readPipeline(workspace)
+              const artifacts = {}
+              for (const rel of [
+                'review-stage/REVIEW_STATE.json',
+                'review-stage/AUTO_REVIEW.md',
+                'review-stage/REVIEWER_MEMORY.md',
+                'review-stage/ACQUITTAL_LOG.jsonl',
+                'IDEA_REPORT.md',
+                'idea-stage/IDEA_REPORT.md',
+                'refine-logs/FINAL_PROPOSAL.md',
+                'refine-logs/EXPERIMENT_PLAN.md',
+                'research-wiki/index.md',
+                'research-wiki/query_pack.md',
+              ]) {
+                artifacts[rel] = await statFile(workspace, rel)
+              }
+              return { ok: true, value: { workspace, state, pipeline, artifacts } }
+            }
+            case 'wiki': {
+              return { ok: true, value: await readWiki(workspace) }
+            }
+            case 'ideas': {
+              return { ok: true, value: await readIdeaBoard(workspace) }
+            }
+            case 'experiments': {
+              return { ok: true, value: await readExperiments(workspace) }
+            }
+            case 'launch': {
+              const skill = typeof payload === 'object' && payload !== null ? payload.skill : undefined
+              const args = typeof payload === 'object' && payload !== null ? payload.args : undefined
+              if (typeof skill !== 'string' || skill === '') {
+                return { ok: false, error: { code: 'bad-request', message: 'skill is required', details: {} } }
+              }
+              const argText = typeof args === 'string' && args.trim() !== '' ? ' 参数/方向：' + args.trim() : ''
+              const prompt = '请使用 ARIS 技能 ' + TICK + skill + TICK + ' 完成对应工作流。' + argText
+              const messageId = 'aris-launch-' + Date.now() + '-' + Math.random().toString(36).slice(2, 8)
+              const message = {
+                id: messageId,
+                role: 'user',
+                content: [{ type: 'text', text: prompt }],
+                source: { kind: 'plugin', plugin: 'dsh-aris' },
+              }
+              let injected = false
+              let method = 'none'
+              try {
+                const agent = scoped.agents && typeof scoped.agents.get === 'function' ? scoped.agents.get(sessionId) : undefined
+                if (agent && typeof agent.send === 'function') {
+                  agent.send(message, 'next-turn', true)
+                  injected = true
+                  method = 'agent.send'
+                }
+              } catch (e) { /* fall through to session.append */ }
+              if (!injected) {
+                try {
+                  const session = scoped.sessions.get(sessionId)
+                  if (session && typeof session.append === 'function') {
+                    session.append('user/message', message)
+                    injected = true
+                    method = 'session.append'
+                  }
+                } catch (e) {
+                  return { ok: false, error: { code: 'internal', message: String(e && e.message || e), details: {} } }
+                }
+              }
+              return { ok: true, value: { injected, method, prompt, sessionId, messageId } }
+            }
+            default:
+              return { ok: false, error: { code: 'internal', message: 'unknown ARIS workbench endpoint \"' + endpoint + '\"' } }
+          }
+        } catch (error) {
+          return { ok: false, error: { code: 'internal', message: String(error && error.message || error), details: {} } }
+        }
+      },
+      { authority: 'loopback' },
+    ), 'ARIS workbench RPC')
+  })
+}