@open-mercato/cli 0.6.7-develop.6685.1.77c0a5591b → 0.6.7-develop.6687.1.46a258e592

package/dist/agentic/shared/ai/skills/tiers.json

@@ -3,30 +3,146 @@
   "default": ["core"],
   "external": {
     "source": "open-mercato/skills",
-    "description": "Skills installed from the shared open-mercato/skills collection via `npx skills add` (see scripts/install-skills.sh). Only the subset this standalone app ships is installed. A folder under .ai/skills/ matching one of these names is a repo-local override read by the external skill, never symlinked into the harness directories.",
+    "ref": "c6103c034571f3610323a1b53d97c81abe110b58",
+    "description": "Tier-selected delivery workflows installed at an exact tested collection commit. Same-name folders under .ai/skills are repo-local overrides and never replace these copies.",
+    "tiers": {
+      "core": {
+        "description": "Smallest dependency-closed set for daily standalone delivery.",
+        "skills": [
+          "om-spec-writing",
+          "om-code-review",
+          "om-integration-tests",
+          "om-prepare-test-env",
+          "om-auto-create-pr",
+          "om-auto-continue-pr",
+          "om-auto-review-pr",
+          "om-auto-implement-spec",
+          "om-auto-qa-pr",
+          "om-auto-fix-issue",
+          "om-verify-in-repo",
+          "om-root-cause",
+          "om-fix",
+          "om-open-pr",
+          "om-setup-agent-pipeline"
+        ]
+      },
+      "automation": {
+        "description": "Opt-in loop engines, issue authoring, and release-upgrade maintenance.",
+        "skills": [
+          "om-apply-upgrade-notes",
+          "om-auto-create-pr-loop",
+          "om-auto-continue-pr-loop",
+          "om-auto-write-spec",
+          "om-prepare-issue"
+        ]
+      }
+    },
     "skills": [
+      "om-spec-writing",
+      "om-code-review",
+      "om-integration-tests",
+      "om-prepare-test-env",
       "om-apply-upgrade-notes",
-      "om-auto-continue-pr",
-      "om-auto-continue-pr-loop",
       "om-auto-create-pr",
+      "om-auto-continue-pr",
       "om-auto-create-pr-loop",
-      "om-auto-fix-issue",
+      "om-auto-continue-pr-loop",
       "om-auto-review-pr",
-      "om-code-review",
-      "om-fix",
-      "om-integration-tests",
-      "om-open-pr",
+      "om-auto-implement-spec",
+      "om-auto-write-spec",
+      "om-auto-qa-pr",
+      "om-auto-fix-issue",
       "om-prepare-issue",
-      "om-prepare-test-env",
+      "om-verify-in-repo",
       "om-root-cause",
-      "om-setup-agent-pipeline",
-      "om-spec-writing",
-      "om-verify-in-repo"
-    ]
+      "om-fix",
+      "om-open-pr",
+      "om-setup-agent-pipeline"
+    ],
+    "dependencies": {
+      "om-spec-writing": [],
+      "om-code-review": ["om-setup-agent-pipeline"],
+      "om-integration-tests": ["om-prepare-test-env"],
+      "om-prepare-test-env": [],
+      "om-apply-upgrade-notes": ["om-setup-agent-pipeline"],
+      "om-auto-create-pr": ["om-auto-review-pr", "om-setup-agent-pipeline"],
+      "om-auto-continue-pr": ["om-auto-review-pr", "om-setup-agent-pipeline"],
+      "om-auto-create-pr-loop": [
+        "om-auto-continue-pr-loop",
+        "om-auto-review-pr",
+        "om-integration-tests",
+        "om-setup-agent-pipeline"
+      ],
+      "om-auto-continue-pr-loop": [
+        "om-auto-review-pr",
+        "om-integration-tests",
+        "om-open-pr",
+        "om-setup-agent-pipeline"
+      ],
+      "om-auto-review-pr": ["om-code-review", "om-setup-agent-pipeline"],
+      "om-auto-implement-spec": [
+        "om-auto-create-pr",
+        "om-auto-continue-pr",
+        "om-auto-review-pr",
+        "om-auto-qa-pr",
+        "om-setup-agent-pipeline"
+      ],
+      "om-auto-qa-pr": [
+        "om-auto-review-pr",
+        "om-integration-tests",
+        "om-prepare-test-env",
+        "om-setup-agent-pipeline"
+      ],
+      "om-auto-write-spec": ["om-spec-writing", "om-open-pr", "om-setup-agent-pipeline"],
+      "om-auto-fix-issue": [
+        "om-auto-implement-spec",
+        "om-auto-qa-pr",
+        "om-auto-review-pr",
+        "om-verify-in-repo",
+        "om-root-cause",
+        "om-fix",
+        "om-open-pr",
+        "om-setup-agent-pipeline"
+      ],
+      "om-prepare-issue": [
+        "om-auto-write-spec",
+        "om-auto-fix-issue",
+        "om-auto-implement-spec",
+        "om-spec-writing",
+        "om-setup-agent-pipeline"
+      ],
+      "om-verify-in-repo": ["om-setup-agent-pipeline"],
+      "om-root-cause": ["om-setup-agent-pipeline"],
+      "om-fix": ["om-setup-agent-pipeline"],
+      "om-open-pr": ["om-setup-agent-pipeline"],
+      "om-setup-agent-pipeline": []
+    },
+    "contentHashes": {
+      "om-spec-writing": "sha256:80d5def47ff844748b1c7407cae8b8ee8588ccdfaee54022e15de885d59fa398",
+      "om-code-review": "sha256:f4503da210e6e5eb7d79a0972d3922a2888d8aed93e98a1bb73091c0dc2a750e",
+      "om-integration-tests": "sha256:a1385dbb9fe11fe8c7a16dbe8576e44b9e03f34254e5575955d5a6ea862ee741",
+      "om-prepare-test-env": "sha256:ccfeb9accfffeaf35423576aacc08c9a6e3d3b07ecf8f72da694878fb3a571ab",
+      "om-apply-upgrade-notes": "sha256:15d4166a9229ebe15365ad3ef50919443478ef5f4c1f2e7cccbf1b8a61482d0d",
+      "om-auto-create-pr": "sha256:fe5a8ff632234c74cd1b948dfa2f69bf79683df067d3b8bc116d7a954d017138",
+      "om-auto-continue-pr": "sha256:ced195e0e571672188b34322a9c215df225a9a1822e1db27f6b864b01624e66e",
+      "om-auto-create-pr-loop": "sha256:0e7c015705a89e623c4f6865901121404feb1f443e0e096facb2a337ad9d33a5",
+      "om-auto-continue-pr-loop": "sha256:2997eb7cbf131e1b88abf05ad930e793675c3cd1db1fece18438ec21b327c6ef",
+      "om-auto-review-pr": "sha256:c05b3f45de9563faa0561a3a12129f4fda8bb1780f60d1cdcce7383e75e2d1c5",
+      "om-auto-implement-spec": "sha256:f5408771aa3765c9c8f2709f5d17247d9b8fef19fd2461c2fedf25c90bb8cda7",
+      "om-auto-write-spec": "sha256:b0d79e189fef7f5c03540becda01d933f5153e39276988f58f9c1dd81e9887f7",
+      "om-auto-qa-pr": "sha256:bff71bf4020a1e92b56a17f35f9c63c5f8f942e95048d5bbdf5589443c2cbda9",
+      "om-auto-fix-issue": "sha256:8ca990752fc1e73f2a70902d567b94da6c74b15f4e409410aa27ba09b1506521",
+      "om-prepare-issue": "sha256:07dd578b00902e65abb408e233688675cc92d6783af1a43257ebfd2d5be34663",
+      "om-verify-in-repo": "sha256:2fcf67187b129261aeb59b53c8058e95eb91c1f3c0314756ff5f432a34c43a62",
+      "om-root-cause": "sha256:7c14fd6388ff72c8bb058de905264899b7ee9797bb4985b1891ec2da0ec1c815",
+      "om-fix": "sha256:c9eb58f7834026c13f2533ae6fc4987d32a0e3cec1fd7b220b47d7154ee6e804",
+      "om-open-pr": "sha256:18ef43308dd3e5aff2099b38779cb7447ae26b754d31e18a0f49f857bafdcba7",
+      "om-setup-agent-pipeline": "sha256:6f906df68194af5ef4d40ccaf6f4335d44f45ddcffa6e1f36331291ac90377c8"
+    }
   },
   "tiers": {
     "core": {
-      "description": "Daily-driver standalone skills installed by default.",
+      "description": "Daily standalone architecture, implementation, extension, debugging, and harness-maintenance skills.",
       "skills": [
         "om-help",
         "om-implement-spec",
@@ -34,20 +150,21 @@
         "om-module-scaffold",
         "om-data-model-design",
         "om-system-extension",
+        "om-integration-builder",
+        "om-create-ai-agent",
+        "om-build-workflow",
         "om-troubleshooter",
+        "om-framework-context",
+        "om-evolve-harness",
         "om-eject-and-customize"
       ]
     },
     "automation": {
-      "description": "Module-management helpers. Opt-in.",
+      "description": "Optional advanced delivery workflows and module-footprint maintenance.",
       "skills": ["om-trim-unused-modules"]
     },
-    "infra": {
-      "description": "Rare, special-case skills.",
-      "skills": ["om-integration-builder"]
-    },
     "migration": {
-      "description": "One-shot, version-pinned migrations. Install only when needed.",
+      "description": "One-shot, version-pinned migrations. Install only for the named upgrade.",
       "skills": ["om-auto-upgrade-0.4.10-to-0.5.0"]
     }
   }

package/dist/agentic/shared/ai/skills/tiers.schema.json

@@ -1,88 +1,100 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://open-mercato.dev/schemas/skills/tiers.schema.json",
-  "title": "Open Mercato skills tier manifest",
-  "description": "Manifest mapping skill folders under .ai/skills/ to install tiers consumed by scripts/install-skills.sh.",
+  "title": "Standalone Open Mercato skill manifest",
   "type": "object",
   "additionalProperties": false,
-  "required": ["default", "tiers"],
+  "required": ["default", "external", "tiers"],
   "properties": {
-    "$schema": {
-      "type": "string"
-    },
+    "$schema": { "type": "string" },
     "default": {
       "type": "array",
       "minItems": 1,
-      "items": {
-        "type": "string",
-        "minLength": 1
-      },
-      "description": "Tier names installed when install-skills.sh is invoked with no flags."
+      "uniqueItems": true,
+      "items": { "$ref": "#/$defs/tierName" }
     },
     "agents": {
       "type": "object",
       "additionalProperties": false,
-      "description": "Agent harness settings for install-skills.sh. Skills always install into the canonical .agents/skills/ directory; per-agent symlinks are created only for agents that cannot read it.",
       "properties": {
         "ignore": {
           "type": "array",
-          "description": "Agents whose directories install-skills.sh must never write. Overridden by --ignore-agents.",
-          "items": {
-            "type": "string",
-            "enum": ["claude-code", "codex", "cursor"]
-          }
+          "uniqueItems": true,
+          "items": { "enum": ["claude-code", "codex", "cursor"] }
         }
       }
     },
     "external": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["source", "skills"],
-      "description": "Skills owned by an external collection and installed via `npx skills add` instead of local symlinks. Folders under .ai/skills/ matching these names are repo-local overrides, not installable skills.",
+      "required": ["source", "ref", "tiers", "skills", "dependencies", "contentHashes"],
       "properties": {
-        "source": {
-          "type": "string",
-          "minLength": 1,
-          "description": "The skills package source, e.g. a GitHub owner/repo."
-        },
-        "description": {
-          "type": "string"
+        "source": { "type": "string", "pattern": "^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$" },
+        "ref": { "type": "string", "pattern": "^[a-f0-9]{40}$" },
+        "description": { "type": "string" },
+        "tiers": {
+          "type": "object",
+          "minProperties": 1,
+          "propertyNames": { "$ref": "#/$defs/tierName" },
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["description", "skills"],
+            "properties": {
+              "description": { "type": "string", "minLength": 1 },
+              "skills": {
+                "type": "array",
+                "minItems": 1,
+                "uniqueItems": true,
+                "items": { "$ref": "#/$defs/skillName" }
+              }
+            }
+          }
         },
         "skills": {
           "type": "array",
           "minItems": 1,
-          "items": {
-            "type": "string",
-            "pattern": "^[a-z0-9][a-z0-9._-]*$"
+          "uniqueItems": true,
+          "items": { "$ref": "#/$defs/skillName" }
+        },
+        "dependencies": {
+          "type": "object",
+          "propertyNames": { "pattern": "^[a-z0-9][a-z0-9._-]*$" },
+          "additionalProperties": {
+            "type": "array",
+            "uniqueItems": true,
+            "items": { "$ref": "#/$defs/skillName" }
           }
+        },
+        "contentHashes": {
+          "type": "object",
+          "propertyNames": { "pattern": "^[a-z0-9][a-z0-9._-]*$" },
+          "additionalProperties": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" }
         }
       }
     },
     "tiers": {
       "type": "object",
       "minProperties": 1,
-      "propertyNames": {
-        "pattern": "^[a-z][a-z0-9-]*$"
-      },
+      "propertyNames": { "pattern": "^[a-z][a-z0-9-]*$" },
       "additionalProperties": {
         "type": "object",
         "additionalProperties": false,
         "required": ["description", "skills"],
         "properties": {
-          "description": {
-            "type": "string",
-            "minLength": 1
-          },
+          "description": { "type": "string", "minLength": 1 },
           "skills": {
             "type": "array",
             "minItems": 1,
-            "items": {
-              "type": "string",
-              "pattern": "^[a-z0-9][a-z0-9._-]*$"
-            }
+            "uniqueItems": true,
+            "items": { "$ref": "#/$defs/skillName" }
           }
         }
       }
     }
+  },
+  "$defs": {
+    "skillName": { "type": "string", "pattern": "^[a-z0-9][a-z0-9._-]*$" },
+    "tierName": { "type": "string", "pattern": "^[a-z][a-z0-9-]*$" }
   }
 }

package/dist/agentic/shared/scripts/agent-harness-tool-server.mjs

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+
+const MAX_READ_BYTES = 256 * 1024
+const MAX_WRITE_BYTES = 256 * 1024
+const SAFE_TEXT_EXTENSIONS = new Set([
+  '.cjs', '.css', '.graphql', '.html', '.js', '.json', '.jsx', '.md', '.mdx',
+  '.mjs', '.prisma', '.sql', '.ts', '.tsx', '.txt', '.xml', '.yaml', '.yml',
+])
+const FORBIDDEN_SEGMENTS = new Set(['.git', '.docker', '.kube', '.aws', '.ssh', '.codex', '.claude', 'node_modules', '.next', 'dist'])
+const FORBIDDEN_BASENAMES = new Set([
+  '.npmrc', '.netrc', '.pypirc', '.git-credentials', 'secrets.json', 'credentials.json',
+  'service-account-credentials.json',
+])
+const FORBIDDEN_SECRET_EXTENSIONS = new Set(['.key', '.pem', '.p12', '.pfx'])
+
+function fail(message) {
+  process.stderr.write(`agent-harness-tool-server: ${message}\n`)
+  process.exit(2)
+}
+
+function isInside(root, candidate) {
+  const relative = path.relative(root, candidate)
+  return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative))
+}
+
+function safeRelative(value) {
+  if (typeof value !== 'string' || !value || value.includes('\0') || path.isAbsolute(value)) return false
+  const normalized = value.replaceAll('\\', '/')
+  if (normalized === '.' || normalized.startsWith('../') || normalized.includes('/../')) return false
+  const segments = normalized.split('/')
+  const basename = segments.at(-1) ?? ''
+  if (segments.some((entry) => FORBIDDEN_SEGMENTS.has(entry))) return false
+  if (normalized === '.ai/harness' || normalized.startsWith('.ai/harness/')) return false
+  if (basename === '.env' || basename.startsWith('.env.') || FORBIDDEN_BASENAMES.has(basename)) return false
+  return !FORBIDDEN_SECRET_EXTENSIONS.has(path.extname(basename).toLowerCase())
+}
+
+function globToRegExp(pattern) {
+  let source = '^'
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index]
+    if (char === '*' && pattern[index + 1] === '*') { source += '.*'; index += 1 }
+    else if (char === '*') source += '[^/]*'
+    else if (char === '?') source += '[^/]'
+    else source += char.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  }
+  return new RegExp(`${source}$`)
+}
+
+const rootArg = process.argv[2]
+const mode = process.argv[3]
+let allowedReads
+let allowedWrites
+try { allowedReads = JSON.parse(process.argv[4] ?? '[]') } catch { fail('allowed read set is invalid JSON') }
+try { allowedWrites = JSON.parse(process.argv[5] ?? '[]') } catch { fail('allowed write set is invalid JSON') }
+if (!path.isAbsolute(rootArg ?? '')) fail('root must be absolute')
+if (!['read-only', 'writable'].includes(mode)) fail('mode must be read-only or writable')
+if (!Array.isArray(allowedReads) || allowedReads.some((entry) => !safeRelative(entry) || ['*', '**'].includes(entry))) fail('allowed read set is invalid')
+if (!Array.isArray(allowedWrites) || allowedWrites.some((entry) => !safeRelative(entry))) fail('allowed write set is invalid')
+const root = fs.realpathSync(rootArg)
+const readMatchers = allowedReads.map(globToRegExp)
+const writeMatchers = allowedWrites.map(globToRegExp)
+
+function resolveRead(relative) {
+  if (!safeRelative(relative)) throw new Error('path is outside the allowed app context')
+  const normalized = relative.replaceAll('\\', '/')
+  if (!readMatchers.some((matcher) => matcher.test(normalized))) throw new Error('path is outside the case read allowlist')
+  const lexical = path.resolve(root, relative)
+  if (!isInside(root, lexical)) throw new Error('path escapes the app root')
+  const real = fs.realpathSync(lexical)
+  if (!isInside(root, real)) throw new Error('path resolves outside the app root')
+  const stat = fs.statSync(real)
+  if (!stat.isFile() || stat.size > MAX_READ_BYTES) throw new Error('path must be a bounded regular file')
+  if (!SAFE_TEXT_EXTENSIONS.has(path.extname(real).toLowerCase()) && path.basename(real) !== 'AGENTS.md') throw new Error('path is not an allowed text file')
+  return { real, stat }
+}
+
+function resolveWrite(relative) {
+  if (mode !== 'writable') throw new Error('writes are disabled for this evaluation')
+  if (!safeRelative(relative) || !writeMatchers.some((matcher) => matcher.test(relative.replaceAll('\\', '/')))) throw new Error('path is outside the case write allowlist')
+  const lexical = path.resolve(root, relative)
+  if (!isInside(root, lexical)) throw new Error('path escapes the app root')
+  let cursor = path.dirname(lexical)
+  const missing = []
+  while (cursor !== root && !fs.existsSync(cursor)) { missing.push(cursor); cursor = path.dirname(cursor) }
+  if (!isInside(root, cursor)) throw new Error('write ancestor escapes the app root')
+  for (let current = cursor; current !== root; current = path.dirname(current)) {
+    const stat = fs.lstatSync(current)
+    if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error('write ancestor must be a regular directory')
+  }
+  if (fs.existsSync(lexical)) {
+    const stat = fs.lstatSync(lexical)
+    if (!stat.isFile() || stat.isSymbolicLink() || !isInside(root, fs.realpathSync(lexical))) throw new Error('write target must be a contained regular file')
+  }
+  for (const directory of missing.reverse()) fs.mkdirSync(directory, { mode: 0o700 })
+  return lexical
+}
+
+const tools = [
+  {
+    name: 'read',
+    description: 'Read one exact app-relative instruction, fact, source, or allowed target file. Absolute paths, discovery, credentials, dependencies, Git, and harness internals are rejected.',
+    inputSchema: { type: 'object', additionalProperties: false, required: ['path'], properties: { path: { type: 'string' } } },
+  },
+  ...(mode === 'writable' ? [{
+    name: 'write',
+    description: 'Replace one exact app-relative file declared in the current case write allowlist. The content must be the complete file.',
+    inputSchema: { type: 'object', additionalProperties: false, required: ['path', 'content'], properties: { path: { type: 'string' }, content: { type: 'string' } } },
+  }] : []),
+]
+
+function result(id, value) {
+  process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, result: value })}\n`)
+}
+
+function toolResult(id, text, isError = false) {
+  result(id, { content: [{ type: 'text', text }], ...(isError ? { isError: true } : {}) })
+}
+
+function handle(message) {
+  if (!message || message.jsonrpc !== '2.0') return
+  if (message.method === 'initialize') {
+    result(message.id, {
+      protocolVersion: message.params?.protocolVersion ?? '2025-06-18',
+      capabilities: { tools: { listChanged: false } },
+      serverInfo: { name: 'open-mercato-agent-harness', version: '1.0.0' },
+    })
+    return
+  }
+  if (message.method === 'ping') { result(message.id, {}); return }
+  if (message.method === 'tools/list') { result(message.id, { tools }); return }
+  if (message.method !== 'tools/call') return
+  try {
+    const name = message.params?.name
+    const input = message.params?.arguments ?? {}
+    if (name === 'read') {
+      const { real } = resolveRead(input.path)
+      toolResult(message.id, fs.readFileSync(real, 'utf8'))
+      return
+    }
+    if (name === 'write') {
+      if (typeof input.content !== 'string' || Buffer.byteLength(input.content) > MAX_WRITE_BYTES) throw new Error('content must be a bounded string')
+      const target = resolveWrite(input.path)
+      const temporary = `${target}.om-harness-${process.pid}.tmp`
+      fs.writeFileSync(temporary, input.content, { encoding: 'utf8', mode: 0o600, flag: 'wx' })
+      fs.renameSync(temporary, target)
+      toolResult(message.id, `wrote ${input.path}`)
+      return
+    }
+    throw new Error('unknown tool')
+  } catch (error) {
+    toolResult(message.id, error instanceof Error ? error.message : String(error), true)
+  }
+}
+
+let buffer = ''
+process.stdin.setEncoding('utf8')
+process.stdin.on('data', (chunk) => {
+  buffer += chunk
+  while (true) {
+    const newline = buffer.indexOf('\n')
+    if (newline < 0) break
+    const line = buffer.slice(0, newline).replace(/\r$/, '')
+    buffer = buffer.slice(newline + 1)
+    if (!line.trim()) continue
+    try { handle(JSON.parse(line)) } catch (error) {
+      process.stderr.write(`agent-harness-tool-server: invalid request: ${error instanceof Error ? error.message : String(error)}\n`)
+    }
+  }
+})