@try-works/dsh-recursive-mode 0.3.1 → 0.4.1

package/src/commands.ts

@@ -14,10 +14,17 @@ import { join } from 'node:path'
 import type { RecursiveRuntime } from './runtime.ts'
 import { resolveControlPlaneRoot } from './workspace.ts'
 import { bootstrapScaffold } from './bootstrap.ts'
+import { loadMemoryIndex } from './memory.ts'
+import { explainMemorySelection } from './memory-select.ts'
+import { readFeedback } from './memory-feedback.ts'
+import { closeoutReport } from './closeout-report.ts'
+import { loadRouterPolicy, routerPolicyPath } from './router.ts'
+import { resolveSubagentTarget } from './role-route.ts'
+import { writePolicySelection, type SelectionScope } from './policy-write.ts'
 
-export type RecursiveVerb = 'status' | 'spec' | 'worktree' | 'init' | 'lock' | 'qa' | 'closeout' | 'addendum' | 'review' | 'scratch' | 'bootstrap' | 'list' | 'help'
+export type RecursiveVerb = 'status' | 'spec' | 'worktree' | 'init' | 'lock' | 'qa' | 'closeout' | 'addendum' | 'review' | 'scratch' | 'memory' | 'model' | 'bootstrap' | 'list' | 'help'
 
-export const PRESET_VERBS: RecursiveVerb[] = ['status', 'spec', 'worktree', 'init', 'lock', 'qa', 'closeout', 'addendum', 'review', 'scratch']
+export const PRESET_VERBS: RecursiveVerb[] = ['status', 'spec', 'worktree', 'init', 'lock', 'qa', 'closeout', 'addendum', 'review', 'scratch', 'memory', 'model']
 export const GLOBAL_VERBS: RecursiveVerb[] = ['bootstrap', 'list', 'help']
 export const ALL_VERBS: RecursiveVerb[] = [...PRESET_VERBS, ...GLOBAL_VERBS]
 
@@ -76,6 +83,33 @@ export function executeRecursiveCommand(root: string, rawInput: string): Recursi
         : 'created ' + result.created.length + ' item(s), ' + result.existing.length + ' existing'
       return { kind: 'success', text: 'recursive-mode scaffold repair: ' + summary + ' — root ' + root }
     }
+    case 'memory': {
+      // P4 — THE SELECTOR WITH NO AGENT LOOP, printing its score COMPONENTS. The reference's loader is a
+      // script an agent runs; this is the same job on the surface the plugin already has, and it explains
+      // itself, so "why did the agent get this?" is answerable from a shell rather than only from a test.
+      const phaseMatch = arg.match(/--phase\s+([\d.]+)/)
+      const phase = phaseMatch?.[1]
+      const query = arg.replace(/--phase\s+[\d.]+/, '').trim()
+      if (query === '') {
+        return { kind: 'error', text: 'memory requires a query: /recursive memory <query> [--phase 04]' }
+      }
+      const entries = loadMemoryIndex(root)
+      if (entries.length === 0) {
+        return { kind: 'success', text: 'the memory plane is empty, so nothing is injected rather than fabricating memory' }
+      }
+      const explanation = explainMemorySelection(entries, {
+        query,
+        ...(phase === undefined ? {} : { phase }),
+        // The counters live in the sidecar; the caller reads them, exactly as the runtime does.
+        feedback: readFeedback(root),
+      })
+      const lines = [explanation.rendered]
+      if (explanation.excluded.length > 0) {
+        lines.push('', 'Excluded ' + explanation.excluded.length + ' entry(s):')
+        for (const item of explanation.excluded.slice(0, 5)) lines.push('- ' + item.title + ': ' + item.reason)
+      }
+      return { kind: 'success', text: lines.join('\n') }
+    }
     case 'closeout': {
       const phaseMatch = arg.match(/--phase\s+(\d{2})/)
       const phase = phaseMatch?.[1] ?? ''
@@ -83,7 +117,85 @@ export function executeRecursiveCommand(root: string, rawInput: string): Recursi
       if (!phase || !runId) return { kind: 'error', text: 'closeout requires <run-id> --phase 04|05|06|07|08' }
       const runDir = join(runRoot, runId)
       if (!existsSync(runDir)) return { kind: 'error', text: 'Run not found in current workspace: ' + runId }
-      return { kind: 'success', text: 'closeout scaffolded for ' + runId + ' phase ' + phase }
+      // ⚠ THIS BRANCH USED TO LIE. It returned "closeout scaffolded for <run> phase <n>" having read nothing,
+      // written nothing and checked nothing — a command that reported success for work it never did. It now
+      // runs the LINTER the closeout actually is: it reads the phase artifact and reports what is missing,
+      // and WRITES NOTHING, which is the design the user specified ("like a linter checking if the agent
+      // missed anything; it is not supposed to edit files by itself").
+      try {
+        const report = closeoutReport(runDir, phase)
+        const lines = [
+          report.artifact + ' — ' + (report.exists ? report.status : 'ABSENT'),
+          report.findings.length === 0
+            ? 'fits the required standard.'
+            : report.findings.length + ' finding(s) before it can lock:',
+        ]
+        for (const finding of report.findings.slice(0, 12)) lines.push('- ' + finding.detail)
+        if (report.prerequisites.length > 0) {
+          lines.push('Advisory — earlier phases not yet LOCKED: '
+            + report.prerequisites.map((p) => p.artifact + ' (' + p.status + ')').join(', '))
+        }
+        if (report.addenda.length > 0) lines.push('Addenda cited: ' + report.addenda.length)
+        return { kind: 'success', text: lines.join('\n') }
+      } catch (err) {
+        return { kind: 'error', text: err instanceof Error ? err.message : String(err) }
+      }
+    }
+    case 'model': {
+      // ⚠ FU-19 — THE EFFECTIVE PROVIDER AND MODEL FOR A PHASE, WITH ITS PROVENANCE, and no agent loop. The same
+      // shape as `/recursive memory`: the workflow's own resolution, printed, so "why did this child run on that
+      // model" is answerable without reading the code or starting anything.
+      const phaseMatch = arg.match(/--phase\s+(\S+)/)
+      const roleMatch = arg.match(/--role\s+(\S+)/)
+      // ⚠ QUOTES ARE STRIPPED, because a shell-typed selector often arrives quoted and `--role ""` must be
+      // understood as "no role given" rather than as a role literally named two quote characters. That mistake was
+      // caught by this verb's own spec, which is the point of writing the spec before believing the code.
+      const unquote = (value: string | undefined): string => (value ?? '').replace(/^["']|["']$/g, '').trim()
+      const phase = unquote(phaseMatch?.[1])
+      const role = unquote(roleMatch?.[1])
+      // ⚠ FU-19 — SET OR CLEAR, when the user supplied something to set. A bare `/recursive model` still READS.
+      // The scope is inferred from which selectors were given, so `/recursive model --model cheap` sets the GENERAL
+      // default, `--phase 03 --model cheap` sets that phase's override, and `--role X --provider fork` sets the
+      // role route. `--clear` removes the named fields, or the whole level when none are named.
+      const providerMatch = arg.match(/--provider\s+(\S+)/)
+      const modelMatch = arg.match(/--model\s+(\S+)/)
+      const modelProviderMatch = arg.match(/--model-provider\s+(\S+)/)
+      const clear = /--clear\b/.test(arg)
+      if (providerMatch !== null || modelMatch !== null || modelProviderMatch !== null || clear) {
+        const scope: SelectionScope = phase !== '' ? 'phase' : role !== '' ? 'role' : 'general'
+        const written = writePolicySelection(root, {
+          scope,
+          ...(phase === '' ? {} : { phase }),
+          ...(role === '' ? {} : { role }),
+          ...(providerMatch === null ? {} : { provider: providerMatch[1]! }),
+          ...(modelMatch === null ? {} : { model: modelMatch[1]! }),
+          ...(modelProviderMatch === null ? {} : { modelProvider: modelProviderMatch[1]! }),
+          ...(clear ? { clear: true } : {}),
+        })
+        if ('refused' in written) return { kind: 'error', text: written.refused }
+        return { kind: 'success', text: written.message }
+      }
+      const policy = loadRouterPolicy(routerPolicyPath(root))
+      // `ladderProvider: null` on purpose: this verb reports what is CONFIGURED, and the provider ladder needs a
+      // live host's registered providers to answer. A caller wanting the full answer gets it from a delegation's
+      // routing notes, which is where the resolved ladder actually appears.
+      const target = resolveSubagentTarget({ role, phase, policy, ladderProvider: null })
+      const general = policy.defaults.subagent
+      return {
+        kind: 'success',
+        text: [
+          'effective selection for role ' + (role === '' ? '(none given)' : role) + (phase === '' ? '' : ' in phase ' + phase) + ':',
+          '- subagent provider, who creates the child: ' + (target.provider ?? 'none configured') + '  [from ' + target.chosen.provider + ']',
+          '- model, what the child runs on: ' + (target.model ?? 'inherited — no model is sent') + '  [from ' + target.chosen.model + ']',
+          target.reason,
+          'configured: general ' + (general === undefined ? 'unset' : JSON.stringify(general))
+            + ', phase routes ' + Object.keys(policy.phase_routes ?? {}).length
+            + ', role routes ' + Object.keys(policy.role_routes ?? {}).length,
+          'a model chosen here is checked against what DSH has when a delegation runs: available is applied, missing'
+            + ' is reported and NOT substituted, and unverified means there was no inventory to ask.',
+          '⚠ changing a default applies to FUTURE delegations only — it never rewrites a run\'s recorded history.',
+        ].join('\n'),
+      }
     }
     case 'worktree': {
       // /recursive worktree create <runId> [--base <branch>]
@@ -152,7 +264,7 @@ export function registerRecursiveCommand(
   return ctx.commands.register({
     name: 'recursive',
     description: 'recursive-mode workflow commands (workspace-scoped)',
-    input: { hint: 'status|spec|worktree|init|lock|qa|closeout|addendum|review|scratch|bootstrap|list|help' },
+    input: { hint: 'status|spec|worktree|init|lock|qa|closeout|addendum|review|scratch|memory|bootstrap|list|help' },
     handler: async ({ rawInput, agent }) => {
       const root = await resolveControlPlaneRoot(agent, (recursive as unknown as { workspaceRegistry?: unknown }).workspaceRegistry as never)
       if (!root) {

package/src/config.ts

@@ -0,0 +1,113 @@
+/**
+ * T7 — the plugin's Config: the `recursive` settings namespace.
+ *
+ * HOW THE SETTINGS SERVICE ACTUALLY SEES THIS, measured against
+ * `@deepseek-ai/dsh-settings`'s own types rather than assumed: `describe()` "read[s]
+ * active plugin schemas and their live values", and `update(ns, patch, expectedRevision)`
+ * "merge[s] editable fields into an entry's config". There is **no `register(...)` call
+ * for a plugin to make** — the item's `registerEnforcementSettings(settings)` wording
+ * describes a seam that does not exist. **Declaring this schema IS the registration:**
+ * the Loader owns the profile entry, the service projects the schema into a form, and an
+ * edit re-applies the plugin with the new config. That re-application IS the hot reload,
+ * which is why there is no watcher here to keep in sync.
+ *
+ * VALIDATION IS NOT DUPLICATED. The schema is what the UI reads and what gives the form
+ * its shape; `resolveEnforcementConfig` remains the STRICT validator (unknown keys
+ * rejected, budgets required to be positive integers, fail-loud at load). A schema that
+ * silently coerced a bad value would be a second, weaker contract beside the real one.
+ */
+import z from '@deepseek-ai/schemastery'
+import { DEFAULT_BUDGETS } from './enforcement.ts'
+
+/** One enforcement mode, as the settings form presents it. */
+const enforcementMode = z.union([z.const('strict'), z.const('advisory')])
+
+export interface RecursiveModeBudgets {
+  maxAuditRounds?: number
+  maxRepairAttempts?: number
+  maxDelegationDepth?: number
+  maxChildrenPerPhase?: number
+  maxResultBytes?: number
+}
+
+export interface RecursiveModeEnforcement {
+  preStep?: 'strict' | 'advisory'
+  toolGuards?: 'strict' | 'advisory'
+  tamper?: 'strict' | 'advisory'
+  budgets?: RecursiveModeBudgets
+}
+
+export interface RecursiveModeConfig {
+  /** R4 shell split: expose ONLY the client bundle, registering nothing server-side. */
+  shellOnly?: boolean
+  repoRoot?: string
+  /** T7/T28: the enforcement modes and the budgets, editable live. */
+  enforcement?: RecursiveModeEnforcement
+  /** T7: overrides for the workspace router file — see the schema comment on defaults. */
+  router?: { defaults?: Record<string, string | number | boolean | undefined> }
+}
+
+/**
+ * The schema the settings service discovers. Field descriptions are the form's help
+ * text, so they are written for the person toggling them, not for the reader of this file.
+ */
+export const Config = z.object({
+  shellOnly: z.boolean().default(false).description(
+    'Client-shell only: registers nothing on the server (no tools, no command, no projection).',
+  ),
+  repoRoot: z.string().description(
+    'Control-plane root. Defaults to the process working directory when unset.',
+  ),
+  enforcement: z.object({
+    preStep: enforcementMode.default('advisory').description(
+      'Phase pre-step enforcement: strict refuses an out-of-order transition, advisory warns and proceeds.',
+    ),
+    toolGuards: enforcementMode.default('advisory').description(
+      'Tool guard mode: strict DENIES an out-of-order tool call, advisory allows it and carries the warning.',
+    ),
+    tamper: enforcementMode.default('advisory').description(
+      'Tamper detection: strict refuses an artifact whose LockHash no longer matches its body.',
+    ),
+    budgets: z.object({
+      maxAuditRounds: z.natural().default(DEFAULT_BUDGETS.maxAuditRounds).description(
+        'Rounds one phase audit loop may run, even while every round makes progress.',
+      ),
+      maxRepairAttempts: z.natural().default(DEFAULT_BUDGETS.maxRepairAttempts).description(
+        'How many times a phase may be sent back for repair before the loop stops.',
+      ),
+      maxDelegationDepth: z.natural().default(DEFAULT_BUDGETS.maxDelegationDepth).description(
+        'Ceiling for the WHOLE recursion. A child narrows it; it is never re-granted per level.',
+      ),
+      maxChildrenPerPhase: z.natural().default(DEFAULT_BUDGETS.maxChildrenPerPhase).description(
+        'Delegated children one phase may start, counted by distinct operation.',
+      ),
+      maxResultBytes: z.natural().default(DEFAULT_BUDGETS.maxResultBytes).description(
+        'Byte ceiling for one tool result, applied after the finding-count cap.',
+      ),
+    }).description('T28 budgets.'),
+  }).description('The enforcement modes plus the T28 budgets.'),
+  /**
+   * T7 — the ROUTER overrides. Deliberately NO defaults on these fields: `.default()`
+   * would make every field present, and a present field overrides the workspace's
+   * `recursive-router.json` — so defaulting them would silently shadow the declarative
+   * file forever. Absent means "defer to the file"; present means "override it".
+   */
+  router: z.object({
+    defaults: z.object({
+      when_role_unconfigured: z.union([z.const('ask'), z.const('fallback-local')]).description(
+        'What to do when a role has no configured route. Leave unset to use the workspace router file.',
+      ),
+      when_cli_unavailable: z.union([z.const('ask'), z.const('fallback-local')]).description(
+        'What to do when the routed CLI is unavailable. Leave unset to use the workspace router file.',
+      ),
+      when_model_unknown: z.union([z.const('ask'), z.const('fallback-local')]).description(
+        'What to do when a routed model is not a known provider. Leave unset to use the workspace router file.',
+      ),
+      allow_auto_assign_if_single_cli: z.boolean().description(
+        'Assign a role automatically when exactly one CLI is configured. Unset defers to the file.',
+      ),
+      probe_timeout_ms: z.natural().description('CLI capability probe timeout in ms. Unset defers to the file.'),
+      invoke_timeout_ms: z.natural().description('Routed CLI invocation timeout in ms. Unset defers to the file.'),
+    }).description('Router default policy fields this namespace overrides.'),
+  }).description('Overrides for .recursive/config/recursive-router.json — one path, not two.'),
+})