@quill507/dsh-orchestrator-preset 0.1.0

package/install.sh

@@ -0,0 +1,193 @@
+#!/usr/bin/env bash
+#
+# install.sh — install the dsh-orchestrator-preset bundle into a DeepSeek Harness home.
+#
+#   ./install.sh                 # install into $DSH_HOME, or ~/.dsh
+#   DSH_HOME=/tmp/dsh ./install.sh
+#   ./install.sh --check         # run the gates and report, change nothing
+#
+# What it does, in order:
+#   0. gate   — refuse to continue unless the host is >= 0.1.7-rc.1
+#   1. stage  — copy this repository's distributable content to $DSH_HOME/plugins/
+#   2. link   — verify the per-profile symlink that `pnpm install` creates
+#   3. skills — verify the four bundled skills; the bundle's own provider serves
+#              them, so nothing is copied into the user's global skills directory
+#   4. none   — the aegis prefix and its optional description swap ship inside the
+#              bundle as extensions/dsh/aegis-prefix.js; there is no companion
+#              plugin to install, and installing the old one reintroduces a race
+#   5. report — print the profile wiring the user must apply themselves
+#
+# What it deliberately does NOT do: touch a profile's package.json or cordis.patch.yml.
+# Those are the live installation's own files, and cordis.patch.yml is watched live by
+# dsh-hmr, so writing it triggers an immediate full re-assembly of the running host.
+# Steps 2 and 5 print the exact commands instead.
+#
+# MIT licensed. See ./LICENSE.
+
+set -euo pipefail
+
+MIN_HOST_VERSION="0.1.7-rc.1"
+BUNDLE_DIRNAME="dsh-orchestrator-preset-bundle"
+BUNDLE_SCOPE="@local/${BUNDLE_DIRNAME}"
+SKILLS="orch-delegation-brief orch-discussion-protocol orch-evidence-protocol orch-real-path-testing"
+CHECK_ONLY=0
+[ "${1:-}" = "--check" ] && CHECK_ONLY=1
+
+REPO_ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+DSH_HOME="${DSH_HOME:-$HOME/.dsh}"
+if [ ! "$DSH_HOME" = "${DSH_HOME%/}" ]; then DSH_HOME="${DSH_HOME%/}"; fi
+
+say()  { printf '\n== %s\n' "$*"; }
+info() { printf '   %s\n' "$*"; }
+die()  { printf '\n!! %s\n' "$*" >&2; exit 1; }
+
+# --- semver compare -------------------------------------------------------
+# Prints -1/0/1 for $1 vs $2. Handles MAJOR.MINOR.PATCH with an optional
+# `-prerelease` suffix; a release outranks its own prereleases.
+ver_cmp() {
+  local a_core a_pre b_core b_pre
+  a_core="${1%%-*}"; a_pre=""; case "$1" in *-*) a_pre="${1#*-}";; esac
+  b_core="${2%%-*}"; b_pre=""; case "$2" in *-*) b_pre="${2#*-}";; esac
+  local v
+  v="$(printf '%s\n%s\n' "$a_core" "$b_core" | sort -V | head -1)"
+  [ "$v" = "$a_core" ] && [ "$a_core" != "$b_core" ] && { echo -1; return; }
+  [ "$v" = "$b_core" ] && [ "$a_core" != "$b_core" ] && { echo 1;  return; }
+  # equal numeric cores -> compare prerelease
+  [ -z "$a_pre" ] && [ -z "$b_pre" ] && { echo 0; return; }
+  [ -z "$a_pre" ] && { echo 1; return; }
+  [ -z "$b_pre" ] && { echo -1; return; }
+  [ "$a_pre" = "$b_pre" ] && { echo 0; return; }
+  [ "$(printf '%s\n%s\n' "$a_pre" "$b_pre" | sort -V | head -1)" = "$a_pre" ] && { echo -1; return; }
+  echo 1
+}
+
+# --- 0. host version gate -------------------------------------------------
+say "0. host version gate (need >= ${MIN_HOST_VERSION})"
+HOST_BIN="$(command -v dsh || true)"
+[ -n "$HOST_BIN" ] || die "'dsh' not found on PATH. Install DeepSeek Harness, or re-run with it on PATH."
+HOST_VERSION="$("$HOST_BIN" --version 2>/dev/null | tr -d '[:space:]' | head -1)"
+[ -n "$HOST_VERSION" ] || die "could not read a version from 'dsh --version'."
+info "dsh --version = ${HOST_VERSION}"
+if [ "$(ver_cmp "$HOST_VERSION" "$MIN_HOST_VERSION")" = "-1" ]; then
+  die "host ${HOST_VERSION} is older than the required ${MIN_HOST_VERSION}. Refusing to install."
+fi
+info "gate passed"
+
+if [ "$CHECK_ONLY" = "1" ]; then
+  say "--check: gates only, nothing written."
+  exit 0
+fi
+
+# --- 1. stage the bundle --------------------------------------------------
+say "1. stage the bundle into ${DSH_HOME}/plugins/${BUNDLE_DIRNAME}"
+DEST="${DSH_HOME}/plugins/${BUNDLE_DIRNAME}"
+if [ -e "$DEST" ]; then
+  info "already present — leaving it in place (remove it yourself to reinstall)."
+else
+  mkdir -p "$DEST"
+  for item in LICENSE README.md README.zh.md cordis.patch.yml package.json personas tools \
+              lane-composition.mjs plan-aware-persona.mjs routing-sections.mjs; do
+    cp -r "${REPO_ROOT}/${item}" "${DEST}/"
+  done
+  # The repo root IS the bundle content; these belong in the bundle, not to it.
+  info "staged $(find "$DEST" -type f | wc -l) files."
+fi
+
+# --- 2. verify the per-profile link --------------------------------------
+# The bundle is resolved BY NAME from a profile's node_modules, so the symlink
+# belongs in each profile — not inside the bundle. `pnpm install` creates it from
+# the profile's `link:` dependency; this step verifies it and says what is missing.
+say "2. verify the ${BUNDLE_SCOPE} symlink in each profile"
+PROFILES="${DSH_HOME}/profiles"
+if [ ! -d "$PROFILES" ]; then
+  info "no ${PROFILES} yet — nothing to verify."
+else
+  FOUND_PROFILE=0
+  for pdir in "$PROFILES"/*/; do
+    [ -d "$pdir" ] || continue
+    pname="$(basename "$pdir")"
+    case "$pname" in node_modules|shared) continue;; esac
+    FOUND_PROFILE=1
+    link="${pdir}node_modules/@local/${BUNDLE_DIRNAME}"
+    if [ -L "$link" ]; then
+      # test -L, never test -e: Git Bash can silently degrade a link into a copy,
+      # and a copy passes test -e while freezing every later edit to the bundle.
+      info "${pname}: real symlink -> $(readlink "$link")"
+    elif [ -e "$link" ]; then
+      info "${pname}: !! ${link} exists but is NOT a symlink (a copy freezes the bundle)"
+    else
+      info "${pname}: MISSING — run 'pnpm install' in ${pdir} after adding the link: dependency"
+    fi
+  done
+  [ "$FOUND_PROFILE" = "0" ] && info "no profile directories found."
+fi
+
+# --- 3. the four self-authored skills ------------------------------------
+# Nothing to copy. The skills ship inside this bundle and are served by the
+# filesystem skill provider that extensions/dsh/index.js mounts, with
+# includeDefaultRoots:false so the user's global skills directory is left alone.
+# Copying them into $DSH_HOME/skills is what this step used to do, and removing
+# it is the point: a preset should not scatter copies through the user's home.
+say "3. verify the bundled skills (nothing to copy — the bundle's provider serves them)"
+for s in $SKILLS; do
+  [ -f "${REPO_ROOT}/skills/${s}/SKILL.md" ] || die "skills/${s}/SKILL.md is missing from the repository."
+  want=$(grep -m1 '^name:' "${REPO_ROOT}/skills/${s}/SKILL.md" | sed 's/^name:[[:space:]]*//')
+  [ "$want" = "$s" ] || die "skills/${s}: frontmatter name is '$want'; the provider reads the frontmatter, not the directory."
+  if [ -d "${DSH_HOME}/skills/${s}" ]; then
+    info "${s}: a copy also exists in ${DSH_HOME}/skills — redundant, the provider is authoritative"
+  else
+    info "${s}: served by the bundle's provider"
+  fi
+done
+[ -f "${REPO_ROOT}/extensions/dsh/index.js" ] || die "extensions/dsh/index.js is missing — the bundle has no skill provider."
+
+# --- 4. nothing to install ------------------------------------------------
+# The aegis prefix bridge and its optional description swap live in the bundle's
+# own extensions/dsh/aegis-prefix.js, mounted by a row the generator emits. There
+# is no companion plugin, which is deliberate: the two used to be separate
+# plugins, and because both mutate the same skill registrations they raced — the
+# split produced 4 of 22 descriptions localised and two bare names leaking back.
+# One plugin doing both in a single registration pass is what removed the race.
+say "4. nothing to install — extensions/dsh/aegis-prefix.js does this inside the bundle"
+
+# --- 5. what the user must do by hand ------------------------------------
+say "5. the profile wiring (deliberate — see the header of this script)"
+cat <<EOF
+   A profile's own package.json and cordis.patch.yml are the live installation's
+   files, and cordis.patch.yml is watched by dsh-hmr: writing it triggers an
+   immediate full re-assembly. This script therefore stops here and prints the
+   exact edits instead of making them.
+
+   (a) In ~/.dsh/profiles/<profile>/package.json — add the dependency:
+
+         "${BUNDLE_SCOPE}": "link:${DSH_HOME}/plugins/${BUNDLE_DIRNAME}"
+
+       and add the same string to the dsh.profile.bundles array, keeping its
+       position. Then run, in that profile directory:
+
+         pnpm install
+
+       which creates the real symlink under node_modules/@local/.
+
+   (b) In ~/.dsh/profiles/<profile>/cordis.patch.yml — select the preset:
+
+         - id: preset-dsh-orchestrator-preset
+           name: '@deepseek-ai/dsh-agent-preset'
+           config:
+             selectedDefault: dsh-orchestrator-preset
+
+   A patch REPLACES the whole row rather than deep-merging it, so a row that
+   overrides config must restate every key it needs; the snippet above is the
+   whole row, not an addition to a larger one.
+
+   Inspect   ~/.dsh/profiles/<profile>/cordis.patch.yml   <- decides the preset
+   Ignore    ~/.dsh/profiles/<profile>/cordis.yml        <- empty by design
+
+   The GUI preset chooser rewrites cordis.patch.yml in place, so a preset picked
+   in the GUI overwrites selectedDefault and does not restore itself. Re-apply
+   (b) to come back. This script never touches that file, so re-running it is safe.
+
+   Re-run with --check to re-verify the host gate without writing anything.
+EOF
+
+say "done."

package/lane-composition.mjs

@@ -0,0 +1,288 @@
+/**
+ * Lane composition for the `dsh-orchestrator-preset` agent preset — child addressing.
+ *
+ * The preset's nine named `subagent_*` lanes are rows of the preset itself, so
+ * each lane keeps its own persona and `toolFilter` (those faces travel on the
+ * lane row). What the Team layer takes over is the coordinator's control
+ * surface: on the Lead's seat `send_message` / `list_agents` / `interrupt_agent`
+ * resolve to the Team implementations, which address a teammate by NAME and
+ * cannot reach a `subagent_*` child at all, so a Lead delegating through
+ * `subagent_*` lanes has no tool to list, continue, or interrupt them — which is
+ * exactly the three actions this plugin supplies, and nothing else.
+ *
+ * Names are new because `NamedEntries.insert` throws on a duplicate inside one
+ * layer (`dsh-scope/lib/index.js:27-29`) and `tool-agent-team` registers its ten
+ * names under a SINGLE try/catch over its whole set: reusing the Team names
+ * would collide in the Lead's own layer and unwind every Team tool, shared task
+ * board included.
+ *
+ * The tools are registered GLOBALLY — `ctx.tools.register`, once, at mount — and
+ * never into a per-agent scope. Two measured reasons. First, `tools.restrict()`
+ * accepts only GLOBALLY registered names: a scoped registration makes every
+ * lane's deny entry illegal (`tools.restrict() names unknown global tools …`) and
+ * the lane's whole setup then throws, which is how this plugin once took the
+ * entire lane family down. Second, the preset's own control tools
+ * (`send_message` / `list_agents` / `interrupt_agent`) already have exactly this
+ * shape: registered globally by `tool-subagent-control`, then denied per lane by
+ * the same deny lists. Those lists are what keeps these three names off a lane's
+ * seat; the Lead, not being a lane, keeps them.
+ *
+ * Each action passes the live calling Agent (`exec.agent`) as sender/authority and
+ * leaves ownership to the service (`agents.isOwnedBy` is not a gate: it accepts
+ * only live resident children and would reject cold resume). One residual: the
+ * adjacent-agent resume pointer is not injected under the Team assembly, so that
+ * contract is carried by the persona and the `orch-delegation-brief` skill instead.
+ *
+ * @module lane-composition
+ */
+
+import { defineTool } from '@deepseek-ai/dsh-tools'
+
+/** Cordis plugin name. */
+export const name = 'lane-composition'
+
+/**
+ * Three services, and the first is not optional: `tools` is the registry this
+ * plugin registers INTO — reading `ctx.tools` without it throws `cannot get
+ * property "tools" without inject` (cordis' context proxy), which an earlier
+ * revision caught into a warning and thereby registered nothing at all. The
+ * sibling row `@deepseek-ai/dsh-tool-subagent-control` declares `tools` on this
+ * same plane: the precedent that it is reachable here.
+ *
+ * `subagents` is the continuation seam and its catalog; `agents` is the live Agent
+ * registry that turns a durable child id into a status. Both come from `dsh-base`.
+ * No Team service is declared or read: registration is decision-free (no
+ * membership test, no per-agent hook), so an assembly WITHOUT the Team bundle
+ * behaves exactly like one with it.
+ */
+export const inject = ['tools', 'subagents', 'agents']
+
+/**
+ * Refine one child's status through the live Agent registry: `running` for an
+ * active driver, `idle` for a resident Agent between turns, and `ready` when no
+ * live Agent remains. `ready` keeps resumability visible without presenting an
+ * inactive conversation as terminal.
+ *
+ * @param agents - the live Agent registry (`ctx.agents`).
+ * @param id - the child's durable session id.
+ * @returns the status to report for that child.
+ */
+function childStatus(agents, id) {
+  const live = agents.get(id)
+  if (live === undefined) return 'ready'
+  return live.status === 'running' ? 'running' : 'idle'
+}
+
+/**
+ * Project one catalog entry into the model-facing row, or drop a one-shot child.
+ *
+ * A child whose `mode` is not `continuable` can never accept a message, so
+ * offering it would only invite an unaddressable id. The label falls back to the
+ * id because the schema promises a string and the catalog records `label` as
+ * optional.
+ *
+ * @param agents - the live Agent registry (`ctx.agents`).
+ * @param entry - one row from `listChildren`.
+ * @returns the row to report, or undefined for a one-shot child.
+ */
+function projectChild(agents, entry) {
+  if (entry.mode !== 'continuable') return undefined
+  return {
+    id: entry.id,
+    label: entry.label ?? entry.id,
+    status: childStatus(agents, entry.id),
+  }
+}
+
+/**
+ * Build the Lead-side `subagent_children` tool: enumeration of the caller's own
+ * continuable `subagent_*` children by durable agent id.
+ *
+ * The listing is scoped CONSTRUCTIVELY — it queries the caller's own session id
+ * — so every row is necessarily one of the caller's own children.
+ *
+ * @param ctx - the preset's scope context, where `subagents` and `agents` were injected.
+ * @returns the tool definition.
+ */
+function childrenTool(ctx) {
+  return defineTool({
+    name: 'subagent_children',
+    description: 'List YOUR OWN continuable `subagent_*` children by durable agent id, label, and live status. '
+      + '`running` means the child is working now; `idle` means it is resident but between turns; `ready` means no '
+      + 'live Agent remains although the durable session still exists, so it can still be resumed. The `id` reported '
+      + 'here is exactly the `agent_id` that `subagent_send` and `subagent_interrupt` take. This is NOT the Team '
+      + 'roster: `list_agents` lists the Lead and every durable teammate by teammate NAME and cannot address a '
+      + '`subagent_*` child at all. One-shot children are omitted because they cannot be messaged.',
+    parameters: {},
+    output: {
+      schema: {
+        type: 'array',
+        items: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            id: { type: 'string', required: true },
+            label: { type: 'string', required: true },
+            status: { type: 'string', required: true, enum: ['running', 'idle', 'ready'] },
+          },
+        },
+      },
+      render: (_args, entries) => [{
+        type: 'text',
+        text: entries.length === 0
+          ? '(no subagent children)'
+          : entries.map((entry) => `${entry.id} [${entry.status}] — ${entry.label}`).join('\n'),
+      }],
+    },
+    async execute(_args, exec) {
+      const parent = exec.agent
+      if (parent === undefined) throw new Error('subagent_children requires a calling agent (exec.agent was undefined)')
+      const entries = await ctx.subagents.listChildren(parent.session.header.id, exec.signal)
+      return entries.map((entry) => projectChild(ctx.agents, entry)).filter((entry) => entry !== undefined)
+    },
+  })
+}
+
+/**
+ * Build the Lead-side `subagent_send` tool: continuation delivery to one of the
+ * caller's own `subagent_*` children by durable agent id.
+ *
+ * @param ctx - the preset's scope context, where `subagents` was injected.
+ * @returns the tool definition.
+ */
+function sendTool(ctx) {
+  return defineTool({
+    name: 'subagent_send',
+    description: 'Deliver a message to a DIRECT continuable child of your own, addressed by the agent id that '
+      + '`subagent_children` reported. A child that is still working is steered at its nearest step boundary; an '
+      + 'idle child starts a turn; a child that is no longer resident is cold-resumed from its durable session, '
+      + 'which is what makes this the continuation tool. The call returns only confirmation that the message was '
+      + 'DELIVERED — never the child\'s reply — so a failure means the message was NOT delivered. This is NOT the '
+      + 'Team tool: `send_message` addresses a teammate by NAME and cannot reach a `subagent_*` child at all.',
+    parameters: {
+      agent_id: {
+        type: 'string',
+        required: true,
+        description: 'The durable agent id of your direct continuable `subagent_*` child, as reported by `subagent_children`.',
+      },
+      message: {
+        type: 'string',
+        required: true,
+        description: 'The message to deliver to the child.',
+      },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: { messageId: { type: 'string', required: true } },
+      },
+      render: (args, _value) => [{ type: 'text', text: `message delivered to agent ${args.agent_id}` }],
+    },
+    async execute(args, exec) {
+      const sender = exec.agent
+      if (sender === undefined) throw new Error('subagent_send requires a calling agent (exec.agent was undefined)')
+      const content = [{ type: 'text', text: args.message }]
+      return { messageId: await ctx.subagents.sendMessage(sender, args.agent_id, content, { signal: exec.signal }) }
+    },
+  })
+}
+
+/**
+ * Build the Lead-side `subagent_interrupt` tool: cancellation of one running
+ * `subagent_*` child's CURRENT TURN by durable agent id.
+ *
+ * @param ctx - the preset's scope context, where `subagents` was injected.
+ * @returns the tool definition.
+ */
+function interruptTool(ctx) {
+  return defineTool({
+    name: 'subagent_interrupt',
+    description: 'Request cancellation of one running `subagent_*` child\'s CURRENT TURN, addressed by its agent id. '
+      + 'Only the current turn stops: messages already queued for the child stay parked until a later '
+      + '`subagent_send`, agents the child started keep running, and the child itself stays available for '
+      + 'follow-ups. The call returns as soon as the stop request is accepted, so the target may keep running '
+      + 'briefly, and interrupting an already-finished agent is an accepted no-op. Address DIRECT children only; to '
+      + 'stop a grandchild, have the intermediate child interrupt it. This is NOT the Team tool: `interrupt_agent` '
+      + 'addresses a teammate by name and cannot reach a `subagent_*` child at all.',
+    parameters: {
+      agent_id: {
+        type: 'string',
+        required: true,
+        description: 'The durable agent id of the running `subagent_*` child whose current turn should stop.',
+      },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: { accepted: { type: 'boolean', required: true } },
+      },
+      render: (args, _value) => [{ type: 'text', text: `interrupt requested for agent ${args.agent_id}` }],
+    },
+    async execute(args, exec) {
+      const caller = exec.agent
+      if (caller === undefined) throw new Error('subagent_interrupt requires a calling agent (exec.agent was undefined)')
+      await ctx.subagents.interrupt(args.agent_id, { kind: 'ancestor', agent: caller })
+      return { accepted: true }
+    },
+  })
+}
+
+/**
+ * Build the three Lead-side child-addressing tools.
+ *
+ * Exported so the definitions can be constructed and inspected without a live
+ * host: `defineTool` compiles every schema eagerly, so building them IS the
+ * check that the declarations are valid.
+ *
+ * @param ctx - a context carrying the `subagents` and `agents` services.
+ * @returns the enumeration, delivery, and cancellation tools.
+ */
+export function buildChildTools(ctx) {
+  return { children: childrenTool(ctx), send: sendTool(ctx), interrupt: interruptTool(ctx) }
+}
+
+/**
+ * Register the three tools into the GLOBAL layer, once, at mount.
+ *
+ * Global is not a preference: `tools.restrict()` resolves its names against the
+ * global registry, so a lane's deny entry is legal only if the name was
+ * registered here (see the module doc). Registration therefore depends on no
+ * agent, no membership, and no Team service.
+ *
+ * A failure is still contained: a throwing register must not take the preset
+ * down with it, and the warning names the error so a silent feature outage is
+ * still visible in the log.
+ *
+ * @param ctx - the preset's scope context, where the injected services live.
+ * @returns the three tool names and whether registration succeeded.
+ */
+function applyGlobalTools(ctx) {
+  const definitions = Object.values(buildChildTools(ctx))
+  const tools = definitions.map((tool) => tool.name)
+  try {
+    for (const definition of definitions) ctx.tools.register(definition)
+    return { tools, registered: true }
+  } catch (error) {
+    ctx.logger.warn(`lane-composition: child-addressing tools failed to register: ${String(error)}`)
+    return { tools, registered: false }
+  }
+}
+
+/**
+ * Register the child-addressing tools once, globally, when this row mounts.
+ *
+ * Every agent then inherits them, which is why the preset's lane deny lists name
+ * all three: the lists are what keeps the names off a lane's seat while the Lead
+ * keeps them. Nothing here waits on, reads, or depends on the Team bundle.
+ *
+ * @param ctx - the preset's scope context.
+ */
+export function apply(ctx) {
+  const registration = applyGlobalTools(ctx)
+  ctx.logger.info(
+    `lane-composition: registered ${JSON.stringify(registration.tools)} registered=${registration.registered}`,
+  )
+}
+

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@quill507/dsh-orchestrator-preset",
+  "version": "0.1.0",
+  "description": "A thin-shell agent preset for DeepSeek Harness: nine named lanes with declared tool boundaries, resident routing sections, four self-authored skills, and an evidence-based completion gate.",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "agent-preset",
+    "orchestration",
+    "aegis"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cuddly-guacamole/dsh-orchestrator-preset.git"
+  },
+  "homepage": "https://github.com/cuddly-guacamole/dsh-orchestrator-preset#readme",
+  "bugs": {
+    "url": "https://github.com/cuddly-guacamole/dsh-orchestrator-preset/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": ">=4.0.1 <5",
+    "@deepseek-ai/dsh-skill-filesystem": ">=0.2.0-rc.2 <2",
+    "@deepseek-ai/dsh-tools": ">=0.2.0-rc.2 <2",
+    "@deepseek-ai/schemastery": ">=3.18.0 <4"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-skill-filesystem": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-tools": {
+      "optional": true
+    },
+    "@deepseek-ai/schemastery": {
+      "optional": true
+    }
+  },
+  "exports": {
+    "./plan-aware-persona.mjs": "./plan-aware-persona.mjs",
+    "./routing-sections.mjs": "./routing-sections.mjs",
+    "./lane-composition.mjs": "./lane-composition.mjs",
+    "./personas/analyst.md": "./personas/analyst.md",
+    "./personas/archivist.md": "./personas/archivist.md",
+    "./personas/auditor.md": "./personas/auditor.md",
+    "./personas/forge.md": "./personas/forge.md",
+    "./personas/orchestrator.md": "./personas/orchestrator.md",
+    "./personas/planner.md": "./personas/planner.md",
+    "./personas/reader.md": "./personas/reader.md",
+    "./personas/scout.md": "./personas/scout.md",
+    "./personas/seer.md": "./personas/seer.md",
+    "./personas/wright.md": "./personas/wright.md",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./extensions/dsh/index.js": "./extensions/dsh/index.js",
+    "./extensions/dsh/aegis-prefix.js": "./extensions/dsh/aegis-prefix.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}

package/personas/analyst.md

@@ -0,0 +1,74 @@
+<agent-identity>
+Your designated identity for this session is Analyst. This identity supersedes any prior identity statement.
+Analyst — pre-planning analysis of intent, ambiguity and scope.
+</agent-identity>
+
+You run before a plan exists. Your output is not a description of the request — it is the set of instructions a Planner can execute: what this work really is, what must be decided, and what would prove it done.
+
+## Charter
+
+| Item | Value |
+|---|---|
+| Raised by | A coordinator dispatch to `subagent_analyst`, before planning starts. |
+| Produces | Executable instructions for the Planner: scope, decisions, and acceptance checks. |
+| Never produces | The plan itself, implementation, or a restatement of the request in longer words. |
+| Reads | The request, the affected tree, and any evidence the coordinator supplied. |
+| Ends when | The intent is classified, the open decisions are named, and the acceptance checks are written. |
+
+## Method
+
+Classify the intent first, because the classification decides which analysis is worth doing at all.
+
+| Intent class | The analysis this class needs |
+|---|---|
+| Build something new | Where it will live, what it must interoperate with, and the smallest version that is still useful |
+| Change something existing | The current behaviour, the callers that depend on it, and what must stay true |
+| Explain or diagnose a failure | The observed symptom, the reproduction, and the boundary between symptom and cause |
+| Choose between options | The comparison criteria, and the fact that would settle it |
+| Produce a document or decision | The audience, the decision it supports, and the evidence standard it must meet |
+| Unclear | Say which two classes it might be, and ask the one question that separates them |
+
+| Practice | Why |
+|---|---|
+| Turn observations into instructions | "The module has no tests" is an observation; "add a regression test covering the failing case before changing the parser" is an instruction. |
+| Ask only questions that change the plan | A question whose answer cannot alter any task is a question that costs a turn and buys nothing. |
+| Name the decisions the Planner must make | Unnamed decisions get made silently by whoever implements, which is how scope drifts. |
+| Bound the scope explicitly | Say what this work will not touch; silence about scope is read as permission. |
+| Write acceptance before implementation | Each instruction carries the check that would show it done, so the plan cannot end in a subjective finish. |
+| Separate assumption from fact | Label each assumption with the check that would test it, and keep the two visibly apart. |
+| Name the failure path, not only the happy one | Most plans break on the input nobody described, so the analysis should describe it first. |
+| Say what would make the work unnecessary | If a cheaper answer exists, the planner should hear it now rather than after the plan is written. |
+
+## Deliverable
+
+| Part | Content |
+|---|---|
+| Intent | The class from the table above, with one sentence of justification |
+| Scope | In scope, out of scope, and the boundary that decided it |
+| Instructions | Ordered, imperative lines for the Planner — each one a thing to do, not a thing to notice |
+| Decisions | Each decision the plan must make, with the options and the evidence for each |
+| Acceptance | The checks that prove the work done, including the failure path, not only the happy path |
+| Questions | The few questions that genuinely change the plan, each with why it matters |
+| Reuse | Existing material the work should build on, so the plan does not invent a second version of it |
+
+## Reporting as a lane
+
+| Part | Content |
+|---|---|
+| Result | The intent class and the one-sentence scope |
+| Basis | What was inspected to reach it |
+| Assumptions | Each assumption with the check that would test it |
+| Blockers | Decisions that cannot proceed without the user, named so the coordinator can ask once |
+
+## Boundaries
+
+Read-only: this lane analyses the request and the tree it will touch, and its only written artifact is the evidence file for its own task.
+
+## Stop conditions
+
+| Condition | Response |
+|---|---|
+| Intent classified, decisions named, acceptance written | Report and stop |
+| The request is ambiguous between two intents | Return the single separating question rather than planning for both |
+| The scope cannot be bounded from what is available | Say which boundary fact is missing, and stop |
+| The work has grown beyond the request | Say so; expanding scope is the coordinator's call, not this lane's |