@ddtcorex/dsh-maestro-review 0.7.4 → 0.8.0

package/src/host/index.ts

@@ -1,15 +1,37 @@
 import type { Context } from '@deepseek-ai/cordis'
+import { makeSkillProvider, resolveSkillsDir } from './skill-provider.js'
 
 export const name = '@ddtcorex/dsh-maestro-review'
 
 export function apply(ctx: Context): void {
-  ctx.effect(() => ctx.connection.rpc.handle('/dsh-maestro-review', async (endpoint, payload) => {
-    if (endpoint === 'status') return { ok: true, value: { provider: 'gitlab' } }
-    if (endpoint === 'providers') return { ok: true, value: { providers: ['gitlab', 'github'] } }
-    if (endpoint === 'review') {
-      const body = payload as Record<string, unknown> | undefined
-      return { ok: true, value: { received: true, provider: (body as any)?.provider ?? 'gitlab' } }
+  // The bundled DSH tool map is served from here, not from the public
+  // `maestro-skills` plugin: that repo's catalog test requires its skill content
+  // to stay tool-neutral, and this map names harness tools. Wrapped like the
+  // rest of apply(): a missing service or a throwing registration must never
+  // take down the whole plugin tree.
+  try {
+    const skills = (ctx as unknown as { get?: (key: string) => any }).get?.('skills')
+    if (skills?.registerProvider) {
+      ctx.effect(() => {
+        let unregister: (() => void) | undefined
+        try {
+          // Package-root skills/ is resolved at runtime by walking to the
+          // nearest package.json (robust to lib/ vs src/host/ layouts).
+          unregister = skills.registerProvider(() => makeSkillProvider(resolveSkillsDir(__dirname)))
+        } catch (e: any) {
+          try { (ctx as any).logger?.warn?.(`[review] skill provider failed: ${e?.message ?? String(e)}`) } catch {}
+        }
+        return () => { try { unregister?.() } catch {} }
+      }, 'maestro-review:skill')
     }
-    return { ok: false, error: { code: 'bad-request', message: `Unknown endpoint: ${endpoint}`, details: { issues: [{ message: String(endpoint) }] } as any } }
-  }, { authority: 'loopback' }), 'maestro-review rpc')
+  } catch (e: any) {
+    try { (ctx as any).logger?.warn?.(`[review] skill provider effect failed: ${e?.message ?? String(e)}`) } catch {}
+  }
+
+  // No RPC registration here on purpose. The channel belongs to settings-rpc.ts
+  // (row `maestro-review-settings-rpc`), which implements the real endpoints. A
+  // stub in this file used to claim the same channel; that stayed invisible only
+  // because apply() was never mounted. Once the `maestro-review-host` row made
+  // apply() run, both registrations collided and the Settings card died with:
+  //   webserver: duplicate prefix route "/dsh-maestro-review"
 }

package/src/host/orchestrator.ts

@@ -1120,14 +1120,12 @@ export function apply(ctx: Context, config: Config): void {
     const runOnce = async (agentOptions: ModelSelection): Promise<ReviewOutcome> => {
       let capturedFindings: ReviewFinding[] = []
       let handle: AgentHandle | undefined
-      let reviewerContext: Context | undefined
       try {
         handle = await ctx.agents.create({
           sessionId: SessionId(`maestro-reviewer-${payload.mrIid}-${Date.now()}`),
           meta: { cwd: worktreePath ?? tmpdir() },
           agentOptions,
           setup: async (agentCtx) => {
-            reviewerContext = agentCtx
             installModelSelection(agentCtx, { current: agentOptions, assembled: undefined })
             await agentCtx.plugin(ReviewToolPolicy)
             await mountAgentPreset(ctx.agentPresets, agentCtx, 'dsh-maestro-reviewer')
@@ -1173,7 +1171,7 @@ export function apply(ctx: Context, config: Config): void {
         }))
         await whenIdleWithTimeout(handle, effectiveAgentTimeoutMs)
         assertTurnSucceededOrSalvage(handle, capturedFindings.length > 0, 'reviewer')
-        if (reviewProfile !== undefined && (reviewerContext === undefined || loadedReviewProfile(reviewerContext) !== reviewProfile)) {
+        if (reviewProfile !== undefined && loadedReviewProfile(handle.agent) !== reviewProfile) {
           throw new Error(`reviewer did not successfully load the required ${reviewProfile} review skill profile; no findings were posted`)
         }
 

package/src/host/settings-rpc.ts

@@ -210,7 +210,10 @@ export function apply(ctx: Context): void {
       // The proxy reads lanPinEnabled at boot; a reload applies the new gate
       // without waiting for a harness restart.
       await ctx.maestroTunnel.reloadConfig()
-      return ok({ enabled })
+      // The gate lives in the proxy listener, not in the settings store, so a
+      // client cannot infer "live" from a successful write. Say so explicitly
+      // instead of letting the config card imply the gate is already in force.
+      return ok({ enabled, requiresRestart: true })
     }
     if (endpoint === MAESTRO_ENDPOINTS.lanPinRotate) {
       return ok({ pin: await ctx.maestroTunnel.rotateLanPin() })

package/src/host/skill-provider.ts

@@ -0,0 +1,91 @@
+import { existsSync } from 'node:fs'
+import { readFile, stat } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import type { SkillCandidate, SkillDefinition, SkillLookupOptions } from '@deepseek-ai/dsh-skill'
+
+const SKILL_NAME = 'dsh-native-tools'
+
+/**
+ * Resolve the package-root `skills/` dir regardless of module layout. The built
+ * host lib is flat (`lib/index.js` → `../skills`), but under vitest the same
+ * module loads from `src/host/` (→ `../../skills`). Walking to the nearest
+ * `package.json` yields the same package-root `skills/` in both layouts.
+ */
+export function resolveSkillsDir(fromDir: string): string {
+  let dir = fromDir
+  for (let i = 0; i < 6; i++) {
+    try {
+      if (existsSync(join(dir, 'package.json'))) return join(dir, 'skills')
+    } catch { /* keep walking */ }
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return join(fromDir, '..', 'skills')
+}
+
+/** Minimal frontmatter reader for our own SKILL.md — enough for the provider contract. */
+function parseFrontmatter(raw: string): { name: string; description: string; body: string } {
+  const m = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  if (!m) return { name: SKILL_NAME, description: '', body: raw }
+  const fm = m[1].split('\n').reduce<Record<string, string>>((acc, line) => {
+    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/)
+    if (kv) acc[kv[1]] = kv[2].replace(/^["']|["']$/g, '')
+    return acc
+  }, {})
+  return { name: fm.name || SKILL_NAME, description: fm.description || '', body: m[2] }
+}
+
+/**
+ * Provider for the bundled DSH tool map. Served here rather than in the public
+ * `maestro-skills` plugin on purpose: the map names harness tools, and that
+ * repo's catalog test requires its skill content to stay tool-neutral.
+ */
+export function makeSkillProvider(skillsDir: string) {
+  return {
+    // The dsh-skill service attributes candidates through the provider object's
+    // own `name`; a missing one surfaces at runtime as `skill provider
+    // "undefined" returned skill ...` and fails every turn.
+    name: 'maestro-review',
+    async list(_options: SkillLookupOptions): Promise<SkillCandidate[]> {
+      const entry = join(skillsDir, SKILL_NAME)
+      const st = await stat(entry).catch(() => null)
+      if (!st?.isDirectory()) return []
+      const skillFilePath = join(entry, 'SKILL.md')
+      const fileSt = await stat(skillFilePath).catch(() => null)
+      if (!fileSt?.isFile()) return []
+      const raw = await readFile(skillFilePath, 'utf-8').catch(() => null)
+      if (raw === null) return []
+      const { name, description } = parseFrontmatter(raw)
+      return [{
+        name,
+        description,
+        invocation: { modelInvocable: true, userInvocable: true },
+        source: 'custom',
+        provider: 'maestro-review',
+        rank: 360,
+        locator: skillFilePath,
+        path: skillFilePath,
+        resourceBase: { kind: 'directory', path: entry },
+        metadata: { name, description },
+      }]
+    },
+    async get(candidate: SkillCandidate, _options: SkillLookupOptions): Promise<SkillDefinition | undefined> {
+      try {
+        const raw = await readFile(candidate.path as string, 'utf-8')
+        const { name, description, body } = parseFrontmatter(raw)
+        return {
+          name,
+          description,
+          invocation: candidate.invocation,
+          source: candidate.source,
+          provider: candidate.provider,
+          resourceBase: candidate.resourceBase,
+          path: candidate.path,
+          content: body,
+          metadata: candidate.metadata,
+        }
+      } catch { return undefined }
+    },
+  }
+}

package/src/host/skills-tool.ts

@@ -46,26 +46,19 @@ export const REVIEW_PROFILE_SKILLS: Record<ReviewSkillProfile, readonly string[]
 
 export const MAESTRO_SKILLS_INSTALL_COMMAND = 'curl -fsSL https://raw.githubusercontent.com/ddtcorex/maestro-skills/master/install.sh | bash -s -- --scope personal --target dsh --skills govard-toolbox,govard-magento,govard-laravel,govard-symfony,govard-wordpress,php-dev-core,magento2-dev-core,magento2-frontend-dev,magento2-hyva-dev,magento2-code-review,magento2-linter,magento2-security-scan,magento2-performance-audit -y'
 
-// This is deliberately process-local and keyed by the reviewer Agent object,
-// which every Cordis child context inherits. Preset mounting inserts child
-// contexts, so keying on the plugin's context would make a successful load
-// invisible to the orchestrator's agent context.
+// Keyed by the reviewer's Agent object itself, not a Cordis context: `ctx.agent`
+// is not an actual injectable Cordis service anywhere in this composition (it
+// throws "cannot get property agent without inject" whenever read, silently
+// making every post-turn profile check report "not loaded" even after the
+// tool above successfully set it — root-caused 2026-09-14 against a real
+// failed review, reproduced deterministically against real
+// @deepseek-ai/cordis). The tool's own `exec.agent` (a plain, non-Cordis
+// property `ToolExecutionInput` always carries, "set by the agent loop") is
+// the reliable handle — callers pass `handle.agent` from the same
+// `AgentHandle` the orchestrator already holds, which is the identical object.
 const loadedReviewProfiles = new WeakMap<object, ReviewSkillProfile>()
 
-export function loadedReviewProfile(ctx: Context): ReviewSkillProfile | undefined {
-  // Cordis's Context proxy throws synchronously on any property nobody
-  // registered/injected ("cannot get property ... without inject") rather
-  // than returning undefined — so a context where the framework's own
-  // `agent` service isn't available needs a try/catch, not just an
-  // `=== undefined` check, to actually get the "no agent yet" outcome this
-  // function documents. Root-caused 2026-09-14 against a real failed
-  // review (reproduced directly with @deepseek-ai/cordis, not a mock).
-  let agent: object | undefined
-  try {
-    agent = ctx.agent
-  } catch {
-    return undefined
-  }
+export function loadedReviewProfile(agent: object | undefined): ReviewSkillProfile | undefined {
   return agent === undefined ? undefined : loadedReviewProfiles.get(agent)
 }
 

package/templates/reviewer-project.gitlab-ci.yml

@@ -3,7 +3,7 @@ stages: [review]
 
 variables:
   # Image registry — pin the SHA for reproducibility
-  REVIEWER_IMAGE: "ddtcorex/maestro-reviewer:0.7.4"
+  REVIEWER_IMAGE: "ddtcorex/maestro-reviewer:0.8.0"
   # Or use $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA when building the image in the same project
 
 review: