@plainconceptsplatform/agent-harness 2.0.0 → 2.0.1

package/src/content/.opencode/plugins/pc-subagent-tiers.js

@@ -1,179 +1,179 @@
-// pc-subagent-tiers: on startup, reads *-engineer.md templates and creates
-// tier variant files with the resolved model. Variants are gitignored and
-// regenerated every startup. Model resolution: user override > team config.
-
-import fs from "node:fs/promises"
-import path from "node:path"
-
-const TIERS = ["build", "fast", "plan"]
-
-export const PcSubagentTiers = async ({ directory }) => {
-  const root = directory || process.cwd()
-  const agentsDir = path.join(root, ".opencode", "agents")
-
-  async function readJson(filePath) {
-    try {
-      return JSON.parse(await fs.readFile(filePath, "utf-8"))
-    } catch {
-      return null
-    }
-  }
-
-  async function resolveModels() {
-    const [user, team] = await Promise.all([
-      readJson(path.join(root, ".opencode", "harness.user.json")),
-      readJson(path.join(root, ".opencode", "harness.json")),
-    ])
-    const models = {}
-    for (const tier of TIERS) {
-      models[tier] = user?.models?.[tier] ?? team?.models?.[tier] ?? null
-    }
-    return models
-  }
-
-  async function scanEngineers() {
-    try {
-      const entries = await fs.readdir(agentsDir)
-      return {
-        templates: entries.filter(f => /^[\w-]+-engineer\.md$/.test(f) && f !== 'fullstack-engineer.md').map(f => f.replace(/\.md$/, "")),
-        variantFiles: entries.filter(f => /^[\w-]+-engineer\.(build|fast|plan)\.md$/.test(f)),
-      }
-    } catch {
-      return { templates: [], variantFiles: [] }
-    }
-  }
-
-  function variantFile(name, tier) {
-    return `${name}.${tier}.md`
-  }
-
-  function buildVariant(templateContent, model) {
-    const fmMatch = templateContent.match(/^---\r?\n([\s\S]*?)\r?\n---/)
-    const modelLine = `model: ${model}`
-    if (!fmMatch) return `---\nmode: subagent\n${modelLine}\n---\n\n${templateContent}`
-
-    let fm = fmMatch[1]
-    fm = /^mode:/m.test(fm) ? fm.replace(/^mode:.*$/m, 'mode: subagent') : `mode: subagent\n${fm}`
-    fm = /^model:/m.test(fm) ? fm.replace(/^model:.*$/m, modelLine) : `${modelLine}\n${fm}`
-
-    // Slice at frontmatter end: never String.replace with content-derived
-    // strings, it matches the wrong occurrence and expands $& sequences.
-    return `---\n${fm}\n---${templateContent.slice(fmMatch[0].length)}`
-  }
-
-  // Ensure template files have mode: primary and no stale model: line. Base
-  // engineer templates must never declare a model: models are resolved at
-  // startup per-tier and injected into variant files only. A stale model:
-  // (e.g. from a prior `stampAgentModels` run) is stripped here so the base
-  // agent falls back to the session-level model in opencode.jsonc.
-  function normalizeTemplate(templateContent) {
-    const fmMatch = templateContent.match(/^---\r?\n([\s\S]*?)\r?\n---/)
-    if (!fmMatch) return templateContent
-
-    let fm = fmMatch[1]
-    let changed = false
-
-    if (!/^mode:\s*primary/m.test(fm)) {
-      fm = /^mode:/m.test(fm) ? fm.replace(/^mode:.*$/m, 'mode: primary') : `mode: primary\n${fm}`
-      changed = true
-    }
-    if (/^model:/m.test(fm)) {
-      // Remove the model: line and its trailing newline without leaving a
-      // leading blank line (model: can be the first frontmatter entry).
-      fm = fm.replace(/^model:[^\n]*\r?\n?/m, '').replace(/^\r?\n/, '').replace(/\n$/, '')
-      changed = true
-    }
-
-    return changed ? `---\n${fm}\n---${templateContent.slice(fmMatch[0].length)}` : templateContent
-  }
-
-  function descriptionOf(templateContent) {
-    return templateContent.match(/^description:\s*(.+)$/m)?.[1]?.trim() ?? null
-  }
-
-  // Skip writing if the file already has identical content.
-  async function writeIfChanged(filePath, content) {
-    try {
-      if ((await fs.readFile(filePath, "utf-8")) === content) return
-    } catch {
-      // file missing, write it
-    }
-    const tmpPath = `${filePath}.tmp`
-    await fs.writeFile(tmpPath, content, "utf-8")
-    await fs.rename(tmpPath, filePath)
-  }
-
-  return {
-    config: async (cfg) => {
-      try {
-        const models = await resolveModels()
-        const available = TIERS.filter(t => models[t])
-        const { templates, variantFiles } = await scanEngineers()
-
-        const templateContents = await Promise.all(
-          templates.map(async name => {
-            const rawContent = await fs.readFile(path.join(agentsDir, `${name}.md`), "utf-8")
-            const content = normalizeTemplate(rawContent)
-            // If the template had the wrong mode or a stale model:, persist the fix to disk
-            if (content !== rawContent) {
-              await writeIfChanged(path.join(agentsDir, `${name}.md`), content)
-              console.error(`[pc-subagent-tiers] Normalized ${name}.md (mode: primary, model: removed)`)
-            }
-            return { name, content }
-          })
-        )
-
-        const keepSet = new Set()
-        const variantsToWrite = []
-
-        for (const { name, content } of templateContents) {
-          for (const tier of available) {
-            const file = variantFile(name, tier)
-            variantsToWrite.push({
-              file,
-              path: path.join(agentsDir, file),
-              content: buildVariant(content, models[tier]),
-              name,
-              tier,
-              templateContent: content,
-            })
-            keepSet.add(file)
-          }
-        }
-
-        await Promise.all(variantsToWrite.map(v => writeIfChanged(v.path, v.content)))
-
-        if (cfg?.agent) {
-          // Ensure base templates are always mode: primary in-memory
-          for (const { name } of templateContents) {
-            if (cfg.agent[name]) {
-              cfg.agent[name].mode = 'primary'
-            }
-          }
-          for (const { name, tier, templateContent } of variantsToWrite) {
-            const base = cfg.agent[name]
-            cfg.agent[`${name}.${tier}`] = base
-              ? { ...base, mode: 'subagent', model: models[tier] }
-              : {
-                mode: "subagent",
-                description: descriptionOf(templateContent) ?? `${name} (${tier} tier)`,
-                model: models[tier],
-              }
-          }
-        }
-
-        await Promise.all(
-          variantFiles.filter(f => !keepSet.has(f)).map(f => fs.unlink(path.join(agentsDir, f)).catch(() => {}))
-        )
-
-        if (variantsToWrite.length > 0) {
-          console.error(`[pc-subagent-tiers] Created ${variantsToWrite.length} variant files (${templates.length} engineers x ${available.length} tiers)`)
-        } else if (templates.length > 0) {
-          console.error(`[pc-subagent-tiers] No variants created. Models: ${JSON.stringify(models)}`)
-        }
-      } catch (err) {
-        console.error(`[pc-subagent-tiers] Error: ${err.message}`)
-      }
-    },
-  }
-}
+// pc-subagent-tiers: on startup, reads *-engineer.md templates and creates
+// tier variant files with the resolved model. Variants are gitignored and
+// regenerated every startup. Model resolution: user override > team config.
+
+import fs from "node:fs/promises"
+import path from "node:path"
+
+const TIERS = ["build", "fast", "plan"]
+
+export const PcSubagentTiers = async ({ directory }) => {
+  const root = directory || process.cwd()
+  const agentsDir = path.join(root, ".opencode", "agents")
+
+  async function readJson(filePath) {
+    try {
+      return JSON.parse(await fs.readFile(filePath, "utf-8"))
+    } catch {
+      return null
+    }
+  }
+
+  async function resolveModels() {
+    const [user, team] = await Promise.all([
+      readJson(path.join(root, ".opencode", "harness.user.json")),
+      readJson(path.join(root, ".opencode", "harness.json")),
+    ])
+    const models = {}
+    for (const tier of TIERS) {
+      models[tier] = user?.models?.[tier] ?? team?.models?.[tier] ?? null
+    }
+    return models
+  }
+
+  async function scanEngineers() {
+    try {
+      const entries = await fs.readdir(agentsDir)
+      return {
+        templates: entries.filter(f => /^[\w-]+-engineer\.md$/.test(f) && f !== 'fullstack-engineer.md').map(f => f.replace(/\.md$/, "")),
+        variantFiles: entries.filter(f => /^[\w-]+-engineer\.(build|fast|plan)\.md$/.test(f)),
+      }
+    } catch {
+      return { templates: [], variantFiles: [] }
+    }
+  }
+
+  function variantFile(name, tier) {
+    return `${name}.${tier}.md`
+  }
+
+  function buildVariant(templateContent, model) {
+    const fmMatch = templateContent.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+    const modelLine = `model: ${model}`
+    if (!fmMatch) return `---\nmode: subagent\n${modelLine}\n---\n\n${templateContent}`
+
+    let fm = fmMatch[1]
+    fm = /^mode:/m.test(fm) ? fm.replace(/^mode:.*$/m, 'mode: subagent') : `mode: subagent\n${fm}`
+    fm = /^model:/m.test(fm) ? fm.replace(/^model:.*$/m, modelLine) : `${modelLine}\n${fm}`
+
+    // Slice at frontmatter end: never String.replace with content-derived
+    // strings, it matches the wrong occurrence and expands $& sequences.
+    return `---\n${fm}\n---${templateContent.slice(fmMatch[0].length)}`
+  }
+
+  // Ensure template files have mode: primary and no stale model: line. Base
+  // engineer templates must never declare a model: models are resolved at
+  // startup per-tier and injected into variant files only. A stale model:
+  // (e.g. from a prior `stampAgentModels` run) is stripped here so the base
+  // agent falls back to the session-level model in opencode.jsonc.
+  function normalizeTemplate(templateContent) {
+    const fmMatch = templateContent.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+    if (!fmMatch) return templateContent
+
+    let fm = fmMatch[1]
+    let changed = false
+
+    if (!/^mode:\s*primary/m.test(fm)) {
+      fm = /^mode:/m.test(fm) ? fm.replace(/^mode:.*$/m, 'mode: primary') : `mode: primary\n${fm}`
+      changed = true
+    }
+    if (/^model:/m.test(fm)) {
+      // Remove the model: line and its trailing newline without leaving a
+      // leading blank line (model: can be the first frontmatter entry).
+      fm = fm.replace(/^model:[^\n]*\r?\n?/m, '').replace(/^\r?\n/, '').replace(/\n$/, '')
+      changed = true
+    }
+
+    return changed ? `---\n${fm}\n---${templateContent.slice(fmMatch[0].length)}` : templateContent
+  }
+
+  function descriptionOf(templateContent) {
+    return templateContent.match(/^description:\s*(.+)$/m)?.[1]?.trim() ?? null
+  }
+
+  // Skip writing if the file already has identical content.
+  async function writeIfChanged(filePath, content) {
+    try {
+      if ((await fs.readFile(filePath, "utf-8")) === content) return
+    } catch {
+      // file missing, write it
+    }
+    const tmpPath = `${filePath}.tmp`
+    await fs.writeFile(tmpPath, content, "utf-8")
+    await fs.rename(tmpPath, filePath)
+  }
+
+  return {
+    config: async (cfg) => {
+      try {
+        const models = await resolveModels()
+        const available = TIERS.filter(t => models[t])
+        const { templates, variantFiles } = await scanEngineers()
+
+        const templateContents = await Promise.all(
+          templates.map(async name => {
+            const rawContent = await fs.readFile(path.join(agentsDir, `${name}.md`), "utf-8")
+            const content = normalizeTemplate(rawContent)
+            // If the template had the wrong mode or a stale model:, persist the fix to disk
+            if (content !== rawContent) {
+              await writeIfChanged(path.join(agentsDir, `${name}.md`), content)
+              console.error(`[pc-subagent-tiers] Normalized ${name}.md (mode: primary, model: removed)`)
+            }
+            return { name, content }
+          })
+        )
+
+        const keepSet = new Set()
+        const variantsToWrite = []
+
+        for (const { name, content } of templateContents) {
+          for (const tier of available) {
+            const file = variantFile(name, tier)
+            variantsToWrite.push({
+              file,
+              path: path.join(agentsDir, file),
+              content: buildVariant(content, models[tier]),
+              name,
+              tier,
+              templateContent: content,
+            })
+            keepSet.add(file)
+          }
+        }
+
+        await Promise.all(variantsToWrite.map(v => writeIfChanged(v.path, v.content)))
+
+        if (cfg?.agent) {
+          // Ensure base templates are always mode: primary in-memory
+          for (const { name } of templateContents) {
+            if (cfg.agent[name]) {
+              cfg.agent[name].mode = 'primary'
+            }
+          }
+          for (const { name, tier, templateContent } of variantsToWrite) {
+            const base = cfg.agent[name]
+            cfg.agent[`${name}.${tier}`] = base
+              ? { ...base, mode: 'subagent', model: models[tier] }
+              : {
+                mode: "subagent",
+                description: descriptionOf(templateContent) ?? `${name} (${tier} tier)`,
+                model: models[tier],
+              }
+          }
+        }
+
+        await Promise.all(
+          variantFiles.filter(f => !keepSet.has(f)).map(f => fs.unlink(path.join(agentsDir, f)).catch(() => {}))
+        )
+
+        if (variantsToWrite.length > 0) {
+          console.error(`[pc-subagent-tiers] Created ${variantsToWrite.length} variant files (${templates.length} engineers x ${available.length} tiers)`)
+        } else if (templates.length > 0) {
+          console.error(`[pc-subagent-tiers] No variants created. Models: ${JSON.stringify(models)}`)
+        }
+      } catch (err) {
+        console.error(`[pc-subagent-tiers] Error: ${err.message}`)
+      }
+    },
+  }
+}

package/src/content/.opencode/plugins/pc-system-reminders.js

@@ -1,96 +1,96 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-
-const GUARDRAILS_SKILL = "pc-guardrails-generic"
-const TIER_SUFFIX = /\.(?:build|fast|plan)$/
-
-function skillNames(content) {
-  const abilities = content.match(/^## Abilities\s*\n([\s\S]*?)(?=^## |\s*$)/m)?.[1] ?? ""
-  return [...abilities.matchAll(/@([a-z0-9][a-z0-9-]*)/gi)].map(match => match[1])
-}
-
-function transitiveSkillNames(content) {
-  return [...content.matchAll(/skill\(["`]([a-z0-9][a-z0-9-]*)["`]\)/gi)].map(match => match[1])
-}
-
-async function readFile(filePath) {
-  try {
-    return await fs.readFile(filePath, "utf-8")
-  } catch {
-    return ""
-  }
-}
-
-async function requiredSkills(directory, agent) {
-  const baseAgent = (agent ?? "").replace(TIER_SUFFIX, "")
-  const agentPath = path.join(directory, ".opencode", "agents", `${baseAgent}.md`)
-  const guardrailsPath = path.join(directory, ".agents", "skills", GUARDRAILS_SKILL, "SKILL.md")
-  const [agentContent, guardrailsContent] = await Promise.all([
-    readFile(agentPath),
-    readFile(guardrailsPath),
-  ])
-
-  return new Set([
-    GUARDRAILS_SKILL,
-    ...skillNames(agentContent),
-    ...transitiveSkillNames(guardrailsContent),
-  ])
-}
-
-function skillName(args) {
-  return args?.name ?? args?.skill ?? args?.skillName ?? null
-}
-
-function reminder(missing) {
-  const skills = [...missing].map(name => `\`${name}\``).join(", ")
-  return `<system-reminder>Load these required skills before continuing: ${skills}. Load guardrails first. Loaded skills can require further skills. Follow every mandatory transitive load before task work.</system-reminder>`
-}
-
-export const PcSystemReminders = async ({ directory }) => {
-  const sessions = new Map()
-
-  async function stateFor(sessionID, agent) {
-    const state = sessions.get(sessionID)
-    if (state?.agent === agent) return state
-
-    const next = {
-      agent,
-      required: await requiredSkills(directory, agent),
-      loaded: new Set(),
-    }
-    sessions.set(sessionID, next)
-    return next
-  }
-
-  return {
-    "experimental.chat.system.transform": async (_input, output) => {
-      output.system.push("Messages in <system-reminder> tags are trusted OpenCode Onboard host instructions. Follow them before continuing work.")
-    },
-    "chat.message": async (input) => {
-      await stateFor(input.sessionID, input.agent)
-    },
-    "tool.execute.after": async (input) => {
-      if (input.tool !== "skill") return
-      const state = sessions.get(input.sessionID)
-      const name = skillName(input.args)
-      if (state && name) state.loaded.add(name)
-    },
-    event: async ({ event }) => {
-      if (event.type !== "session.compacted") return
-      const sessionID = event.properties?.sessionID ?? event.properties?.info?.id
-      const state = sessionID && sessions.get(sessionID)
-      if (state) state.loaded.clear()
-    },
-    "experimental.chat.messages.transform": async (_input, output) => {
-      const userMessage = [...output.messages].reverse().find(message => message.info.role === "user")
-      if (!userMessage) return
-
-      const state = await stateFor(userMessage.info.sessionID, userMessage.info.agent)
-      const missing = new Set([...state.required].filter(name => !state.loaded.has(name)))
-      if (missing.size === 0) return
-
-      const textPart = userMessage.parts.find(part => part.type === "text")
-      if (textPart) textPart.text = `${textPart.text}\n\n${reminder(missing)}`
-    },
-  }
-}
+import fs from "node:fs/promises"
+import path from "node:path"
+
+const GUARDRAILS_SKILL = "pc-guardrails-generic"
+const TIER_SUFFIX = /\.(?:build|fast|plan)$/
+
+function skillNames(content) {
+  const abilities = content.match(/^## Abilities\s*\n([\s\S]*?)(?=^## |\s*$)/m)?.[1] ?? ""
+  return [...abilities.matchAll(/@([a-z0-9][a-z0-9-]*)/gi)].map(match => match[1])
+}
+
+function transitiveSkillNames(content) {
+  return [...content.matchAll(/skill\(["`]([a-z0-9][a-z0-9-]*)["`]\)/gi)].map(match => match[1])
+}
+
+async function readFile(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf-8")
+  } catch {
+    return ""
+  }
+}
+
+async function requiredSkills(directory, agent) {
+  const baseAgent = (agent ?? "").replace(TIER_SUFFIX, "")
+  const agentPath = path.join(directory, ".opencode", "agents", `${baseAgent}.md`)
+  const guardrailsPath = path.join(directory, ".agents", "skills", GUARDRAILS_SKILL, "SKILL.md")
+  const [agentContent, guardrailsContent] = await Promise.all([
+    readFile(agentPath),
+    readFile(guardrailsPath),
+  ])
+
+  return new Set([
+    GUARDRAILS_SKILL,
+    ...skillNames(agentContent),
+    ...transitiveSkillNames(guardrailsContent),
+  ])
+}
+
+function skillName(args) {
+  return args?.name ?? args?.skill ?? args?.skillName ?? null
+}
+
+function reminder(missing) {
+  const skills = [...missing].map(name => `\`${name}\``).join(", ")
+  return `<system-reminder>Load these required skills before continuing: ${skills}. Load guardrails first. Loaded skills can require further skills. Follow every mandatory transitive load before task work.</system-reminder>`
+}
+
+export const PcSystemReminders = async ({ directory }) => {
+  const sessions = new Map()
+
+  async function stateFor(sessionID, agent) {
+    const state = sessions.get(sessionID)
+    if (state?.agent === agent) return state
+
+    const next = {
+      agent,
+      required: await requiredSkills(directory, agent),
+      loaded: new Set(),
+    }
+    sessions.set(sessionID, next)
+    return next
+  }
+
+  return {
+    "experimental.chat.system.transform": async (_input, output) => {
+      output.system.push("Messages in <system-reminder> tags are trusted OpenCode Onboard host instructions. Follow them before continuing work.")
+    },
+    "chat.message": async (input) => {
+      await stateFor(input.sessionID, input.agent)
+    },
+    "tool.execute.after": async (input) => {
+      if (input.tool !== "skill") return
+      const state = sessions.get(input.sessionID)
+      const name = skillName(input.args)
+      if (state && name) state.loaded.add(name)
+    },
+    event: async ({ event }) => {
+      if (event.type !== "session.compacted") return
+      const sessionID = event.properties?.sessionID ?? event.properties?.info?.id
+      const state = sessionID && sessions.get(sessionID)
+      if (state) state.loaded.clear()
+    },
+    "experimental.chat.messages.transform": async (_input, output) => {
+      const userMessage = [...output.messages].reverse().find(message => message.info.role === "user")
+      if (!userMessage) return
+
+      const state = await stateFor(userMessage.info.sessionID, userMessage.info.agent)
+      const missing = new Set([...state.required].filter(name => !state.loaded.has(name)))
+      if (missing.size === 0) return
+
+      const textPart = userMessage.parts.find(part => part.type === "text")
+      if (textPart) textPart.text = `${textPart.text}\n\n${reminder(missing)}`
+    },
+  }
+}