@mars.liu/dsh-cybernetics 0.2.0 → 0.7.8

package/src/upstream.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Minimal ambient declarations for the DSH host packages this plugin is
+ * `link:`-mounted against.
+ *
+ * Rationale: the plugin is deliberately zero-dependency (see src/index.ts), so
+ * `npx tsc --noEmit` in this checkout has no node_modules to resolve the host
+ * packages from. The only upstream surfaces the plugin needs to merge into are
+ * the two merge-extensible type tables below (their real declarations in
+ * @deepseek-ai/dsh-session-projection / @deepseek-ai/dsh-session are exactly
+ * these empty interfaces). Declaring them ambiently keeps the augmentation in
+ * src/projection.ts a valid augmentation instead of a TS2664 error, and keeps
+ * the standalone typecheck at its pre-existing baseline (only the known
+ * TS2307/TS5097 diagnostics from the type-only imports).
+ */
+declare module '@deepseek-ai/dsh-session-projection/types' {
+  export interface SessionProjectionMap {}
+  export interface SessionProjectionStateMap {}
+}
+
+declare module '@deepseek-ai/dsh-session/types' {
+  export interface SessionEventMap {}
+}

package/workflows/round.js

@@ -10,10 +10,17 @@
 //                                                   // primary work order (falls back to the objective)
 //   role:   string,                                 // task agent role key (default 'default')
 //   roles:  { [role]: { provider?, model? } },      // per-role LLM overrides (deployment config)
+//   taskReport?: object,                            // v0.6 TeamExecutor: the persistent teammate's
+//                                                   // report — when present the task agent is skipped
+//                                                   // and verify/triage run over it directly
+//   depth:  'quick' | 'full',                       // quick = task agent only (lightweight analysis:
+//                                                   // one agent, one round, direct feedback — no
+//                                                   // verify/triage); full = the whole loop (default,
+//                                                   // for complex analysis and any world change)
 // }
 // Returns { round, report, verdict, triage } — the controller folds this into the decision.
 
-const { goal, state, subgoal, brief, role, roles } = args
+const { goal, state, subgoal, brief, role, roles, depth, taskReport } = args
 
 // One triaged step; shared by the four triage buckets (plain data, no $ref).
 const stepsItem = {
@@ -29,6 +36,81 @@ const specFor = (key) => {
     : {}
 }
 
+// v0.6 TeamExecutor: the persistent teammate already did the task work; the
+// controller hands its report in as `taskReport`. Skip the task agent entirely
+// and go straight to verify/triage (quick depth returns the derived verdict).
+if (taskReport && typeof taskReport === 'object') {
+  const report = taskReport
+  if (depth === 'quick') {
+    return {
+      round: state.round,
+      report,
+      verdict: {
+        met: report.done === true,
+        quick: true,
+        criteria: [],
+        gaps: report.done === true ? [] : ['task agent 报告 done=false（quick 轮无 verify，详见 report）'],
+        goalItselfQuestionable: false,
+      },
+      triage: { auto: [], defer: [], reject: [], human: [] },
+    }
+  }
+  await phase('verify')
+  const verdict = await agent(
+    [
+      `你是独立的 verify agent：你没有、也不应获得 task agent 的叙述过程。`,
+      `下面是目标、工作委托书和 task agent 的报告，请基于证据判定本轮是否达成目标。`,
+      ``,
+      `【目标】`,
+      goal.objective,
+      ``,
+      `【工作委托书】`,
+      (brief && brief.trim()) || goal.objective,
+      ``,
+      `【task agent 的报告】`,
+      JSON.stringify(report, null, 2),
+      ``,
+      `判定标准：证据是否支撑报告的每一项结论；是否覆盖了本轮子目标；是否存在未验证的断言。`,
+    ].join('\n'),
+    { label: 'verify', ...specFor('verify'), schema: {
+      type: 'object', additionalProperties: false,
+      required: ['met', 'criteria', 'gaps', 'goalItselfQuestionable'],
+      properties: {
+        met: { type: 'boolean' },
+        criteria: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['criterion', 'pass', 'evidence'], properties: { criterion: { type: 'string' }, pass: { type: 'boolean' }, evidence: { type: 'string' } } } },
+        gaps: { type: 'array', items: { type: 'string' } },
+        goalItselfQuestionable: { type: 'boolean' },
+      },
+    } },
+  )
+  await phase('triage')
+  const triage = await agent(
+    [
+      `你是 triage agent：把 verify 的缺口拆成四类处置建议。`,
+      ``,
+      `【verify 判定】`,
+      JSON.stringify(verdict, null, 2),
+      ``,
+      `【本轮子目标】`,
+      subgoal || '',
+    ].join('\n'),
+    { label: 'triage', ...specFor('triage'), schema: {
+      type: 'object', additionalProperties: false,
+      required: ['auto', 'defer', 'reject', 'human'],
+      properties: {
+        auto: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['step', 'rationale'], properties: { step: { type: 'string' }, rationale: { type: 'string' } } } },
+        defer: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['step', 'rationale'], properties: { step: { type: 'string' }, rationale: { type: 'string' } } } },
+        reject: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['step', 'rationale'], properties: { step: { type: 'string' }, rationale: { type: 'string' } } } },
+        human: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['step', 'rationale'], properties: { step: { type: 'string' }, rationale: { type: 'string' }, question: { type: 'string' } } } },
+      },
+    } },
+  )
+  if (verdict === null || triage === null) {
+    return { round: state.round, report, failed: 'verify/triage agent 失败，本轮无结论' }
+  }
+  return { round: state.round, report, verdict, triage }
+}
+
 await phase('task')
 
 // The task agent is an INDEPENDENT subagent: it inherits no conversation
@@ -76,6 +158,24 @@ if (report === null) {
   return { round: state.round, failed: 'task agent 失败，本轮无结果' }
 }
 
+// quick depth: lightweight analysis — one agent, one round, direct feedback.
+// Skip verify/triage entirely; derive a verdict-shaped outcome from the
+// task report so the controller's decision logic works unchanged.
+if (depth === 'quick') {
+  return {
+    round: state.round,
+    report,
+    verdict: {
+      met: report.done === true,
+      quick: true,
+      criteria: [],
+      gaps: report.done === true ? [] : ['task agent 报告 done=false（quick 轮无 verify，详见 report）'],
+      goalItselfQuestionable: false,
+    },
+    triage: { auto: [], defer: [], reject: [], human: [] },
+  }
+}
+
 await phase('verify')
 
 const verdict = await agent(

package/test/v03-offline.mjs

@@ -1,203 +0,0 @@
-// Offline harness test for dsh-cybernetics v0.3: exercises every tool action
-// (list / round / start / collect / cancel) against a fake host ctx and a
-// controllable fake workflow engine — no DSH runtime required.
-// Run: node test/v03-offline.mjs
-
-import assert from 'node:assert/strict'
-import { mkdtemp, readFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { apply } from '../src/index.ts'
-
-// --- fake workflow engine ---------------------------------------------------
-function fakeEngine() {
-  const runs = []
-  return {
-    runs,
-    start(request) {
-      let settle
-      const result = new Promise((resolve) => { settle = resolve })
-      const run = {
-        request,
-        result,
-        cancelled: false,
-        disposed: false,
-        settle(value) { settle(value) },
-        cancel(reason) {
-          run.cancelled = true
-          settle({ stopReason: 'cancelled', error: reason })
-        },
-        async dispose() { run.disposed = true },
-      }
-      runs.push(run)
-      return run
-    },
-  }
-}
-
-// --- fake host ctx ------------------------------------------------------------
-function fakeHost(engine, { activeGoal } = {}) {
-  const tools = []
-  const followups = []
-  const createdGoals = []
-  const parent = {
-    session: { id: 'sess-test' },
-    followup(message) { followups.push(message) },
-  }
-  const rootPromise = mkdtemp(join(tmpdir(), 'cyb-test-'))
-  const ctx = {
-    tools: { register: (d) => { tools.push(d); return () => {} } },
-    systemPrompt: { section() {}, getSectionOrder: () => 0 },
-    goals: {
-      get: () => activeGoal ?? null,
-      create: (_agent, input) => { createdGoals.push(input); return { id: 'goal-focused' } },
-    },
-    workingDirectory: { get: () => '__PENDING__' },
-    agentPresets: { serviceFor: (_agent, name) => (name === 'workflowEngine' ? engine : undefined) },
-  }
-  // workingDirectory.get must be sync in the plugin; pre-resolve the tmp dir.
-  return { ctx, tools, followups, createdGoals, parent, rootPromise }
-}
-
-const engine = fakeEngine()
-const { ctx, tools, followups, createdGoals, parent } = fakeHost(engine)
-const root = await mkdtemp(join(tmpdir(), 'cyb-test-'))
-ctx.workingDirectory = { get: () => root }
-
-let section
-ctx.systemPrompt.section = (s) => { section = s }
-apply(ctx, {})
-const tool = tools[0]
-const exec = { agent: parent, signal: undefined }
-
-// 1. list on an empty board
-{
-  const out = await tool.execute({ action: 'list' }, exec)
-  assert.deepEqual(out.board, [], 'empty board')
-  console.log('✓ 1 list: empty board')
-}
-
-// 2. round with no goal anywhere → guard error
-{
-  await assert.rejects(
-    () => tool.execute({ action: 'round' }, exec),
-    /no active session goal/,
-  )
-  console.log('✓ 2 guard: no goal resolved → structured error')
-}
-
-// 3. start creates a new goal and launches a background round
-let goalId
-{
-  const out = await tool.execute({
-    action: 'start', title: '测试任务A', brief: '完整工作委托书：做 X，验收 Y',
-  }, exec)
-  assert.equal(out.started, true)
-  assert.match(out.goalId, /^cyb-/)
-  assert.equal(out.round, 1)
-  goalId = out.goalId
-  assert.equal(engine.runs.length, 1, 'one workflow run started')
-  assert.equal(engine.runs[0].request.args.brief, '完整工作委托书：做 X，验收 Y', 'brief passed through')
-  assert.equal(createdGoals.length, 1, 'focus goal synced into dsh-goal (slot was free)')
-  assert.match(createdGoals[0].objective, /测试任务A/)
-  console.log('✓ 3 start: goal created, background round launched, brief透传, focus synced')
-}
-
-// 4. collect before settle → pending
-{
-  const out = await tool.execute({ action: 'collect', goalId }, exec)
-  assert.equal(out.pending, true)
-  console.log('✓ 4 collect (running): pending')
-}
-
-// 5. settle the run → completion notice queued into the session inbox
-{
-  const roundResult = {
-    round: 1,
-    report: { summary: '做完了一半', done: false, artifacts: [], evidence: 'e', nextStepThoughts: ['继续另一半'] },
-    verdict: { met: false, criteria: [], gaps: ['另一半没做'], goalItselfQuestionable: false },
-    triage: { auto: [], defer: [], reject: [], human: [] },
-  }
-  engine.runs[0].settle({ stopReason: 'completed', value: roundResult })
-  await new Promise((r) => setImmediate(r))
-  assert.equal(followups.length, 1, 'one completion notice queued')
-  assert.equal(followups[0].role, 'user')
-  assert.equal(followups[0].source.kind, 'cybernetics')
-  assert.equal(followups[0].source.goalId, goalId)
-  assert.match(followups[0].content[0].text, /collect/)
-  console.log('✓ 5 settle: agent.followup completion notice queued')
-}
-
-// 6. collect folds the settled round into a continue decision + audit log
-{
-  const out = await tool.execute({ action: 'collect', goalId }, exec)
-  assert.equal(out.decision.action, 'continue')
-  assert.match(out.decision.subgoal, /另一半没做/, 'subgoal derived from gaps')
-  const log = JSON.parse(await readFile(join(root, '.cybernetics', `round-${goalId}-1.json`), 'utf8'))
-  assert.equal(log.report.summary, '做完了一半', 'audit log written (goal-scoped filename)')
-  console.log(`✓ 6 collect: continue decision from gaps, round-${goalId}-1.json audit log落盘`)
-}
-
-// 7. start a second round then cancel it (correction-interrupt path)
-{
-  const out = await tool.execute({ action: 'start', goalId, brief: '修正：方向改为 Z' }, exec)
-  assert.equal(out.round, 2)
-  const c = await tool.execute({ action: 'cancel', goalId, brief: '用户打断：方向改为 Z' }, exec)
-  assert.ok(c.cancelled)
-  await new Promise((r) => setImmediate(r))
-  const collected = await tool.execute({ action: 'collect', goalId }, exec)
-  assert.equal(collected.decision.action, 'pause')
-  assert.equal(collected.decision.reason, 'failed')
-  assert.match(collected.result.failed, /cancelled/)
-  console.log('✓ 7 cancel: in-flight round aborted, collect folds cancelled outcome')
-}
-
-// 8. blocking round on a SECOND goal; met verdict → pause(met), status tracked
-// (blocking: schedule the settle first, then await the execute promise)
-{
-  const p = tool.execute({ action: 'round', title: '测试任务B', brief: '委托书B' }, exec)
-  // Wait until the execute path has actually started the run (readFile is async).
-  const before = engine.runs.length
-  for (let i = 0; i < 100 && engine.runs.length === before; i++) {
-    await new Promise((r) => setImmediate(r))
-  }
-  const runB = engine.runs.at(-1)
-  runB.settle({
-    stopReason: 'completed',
-    value: {
-      round: 1,
-      report: { summary: 'B 全部完成', done: true, artifacts: ['x'], evidence: 'e', nextStepThoughts: [] },
-      verdict: { met: true, criteria: [], gaps: [], goalItselfQuestionable: false },
-      triage: { auto: [], defer: [], reject: [], human: [] },
-    },
-  })
-  const out = await p
-  assert.equal(out.decision.action, 'pause')
-  assert.equal(out.decision.reason, 'met')
-  assert.ok(out.goalId !== goalId, 'second goal has its own id')
-  console.log('✓ 8 round (blocking): second goal, met → pause(met)')
-}
-
-// 9. list shows both goals with divergent status
-{
-  const out = await tool.execute({ action: 'list' }, exec)
-  assert.equal(out.board.length, 2)
-  const a = out.board.find((g) => g.goalId === goalId)
-  const b = out.board.find((g) => g.goalId !== goalId)
-  assert.equal(a.round, 2)
-  assert.equal(a.running, false)
-  assert.match(a.subgoal, /另一半没做/, 'goal A keeps its own subgoal across B\'s rounds')
-  assert.equal(b.status, 'met')
-  console.log('✓ 9 list: two goals coexist with independent state')
-}
-
-// 10. guidance section encodes the orchestrator protocol
-{
-  assert.match(section.text, /never execute task work/i)
-  assert.match(section.text, /NEW task/)
-  assert.match(section.text, /CORRECTION/)
-  assert.match(section.text, /cancel/)
-  console.log('✓ 10 guidance: orchestrator protocol injected')
-}
-
-console.log('\nALL 10 CHECKS PASSED')

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "strict": true,
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "lib",
-    "rootDir": "src",
-    "verbatimModuleSyntax": true,
-    "skipLibCheck": true
-  },
-  "include": ["src/**/*.ts"]
-}