@etus/seven-skill 0.1.0-beta.3 → 0.1.0-beta.5

package/.claude/skills/seven/scripts/context-signals.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { argValue, loadContext } from './load-context.mjs'
+
+const UI_EXTENSIONS = new Set(['.css', '.html', '.js', '.jsx', '.less', '.mdx', '.scss', '.ts', '.tsx'])
+const scriptsDirectory = path.dirname(fileURLToPath(import.meta.url))
+
+function gitNames(root, args) {
+  const result = spawnSync('git', args, { cwd: root, encoding: 'utf8' })
+  if (result.status !== 0) return []
+  return result.stdout.split('\n').map((item) => item.trim()).filter(Boolean)
+}
+
+function changedUiFiles(root) {
+  const names = new Set([
+    ...gitNames(root, ['diff', '--name-only', '--diff-filter=ACMR']),
+    ...gitNames(root, ['diff', '--cached', '--name-only', '--diff-filter=ACMR']),
+    ...gitNames(root, ['ls-files', '--others', '--exclude-standard']),
+  ])
+  return [...names].filter((name) => UI_EXTENSIONS.has(path.extname(name).toLowerCase())).sort()
+}
+
+function latestReview(root) {
+  const directory = path.join(root, '.seven', 'reviews')
+  let names = []
+  try {
+    names = fs.readdirSync(directory).filter((name) => name.endsWith('.json'))
+  } catch {
+    return null
+  }
+  const candidates = names.map((name) => {
+    const filePath = path.join(directory, name)
+    try {
+      return { filePath, mtime: fs.statSync(filePath).mtimeMs, payload: JSON.parse(fs.readFileSync(filePath, 'utf8')) }
+    } catch {
+      return null
+    }
+  }).filter(Boolean).sort((left, right) => right.mtime - left.mtime)
+  if (!candidates[0]) return null
+  return {
+    path: path.relative(root, candidates[0].filePath).split(path.sep).join('/'),
+    createdAt: candidates[0].payload.createdAt || null,
+    score: candidates[0].payload.score ?? null,
+    p0: candidates[0].payload.summary?.p0 ?? 0,
+    p1: candidates[0].payload.summary?.p1 ?? 0,
+    target: candidates[0].payload.target || null,
+  }
+}
+
+function scanTargets(context, changed) {
+  if (changed.length > 0) return { via: 'git-changes', targets: changed.slice(0, 40) }
+  const roots = Array.isArray(context.project?.sourceRoots) ? context.project.sourceRoots : ['src']
+  const existing = roots.filter((entry) => fs.existsSync(path.join(context.projectRoot, entry)))
+  return { via: 'source-roots', targets: existing.slice(0, 8) }
+}
+
+export async function collectContextSignals(start = process.cwd(), { target = start } = {}) {
+  const context = await loadContext(start, { target })
+  const changed = changedUiFiles(context.projectRoot)
+  return {
+    schemaVersion: 1,
+    projectRoot: context.projectRoot,
+    target: path.resolve(target),
+    setup: {
+      hasProduct: context.hasProduct,
+      productPlaceholder: context.productPlaceholder,
+      hasRelease: Boolean(context.release),
+      register: context.register,
+      app: context.app?.id || null,
+      surface: context.surface?.id || null,
+    },
+    git: { changedFiles: changed },
+    critique: { latest: latestReview(context.projectRoot) },
+    scan: scanTargets(context, changed),
+    live: {
+      session: fs.existsSync(path.join(context.projectRoot, '.seven', 'live', 'session.json')),
+      journal: fs.existsSync(path.join(context.projectRoot, '.seven', 'live', 'journal.ndjson')),
+      extensionPathCommand: `node ${JSON.stringify(path.join(scriptsDirectory, 'run-seven.mjs'))} extension path`,
+    },
+  }
+}
+
+export async function main(argv = process.argv) {
+  const target = argValue('--target', argv) || process.env.SEVEN_TARGET || process.cwd()
+  const signals = await collectContextSignals(target, { target })
+  process.stdout.write(`${JSON.stringify(signals, null, 2)}\n`)
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) await main()

package/.claude/skills/seven/scripts/critique-storage.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { argValue, findRoot, loadContext } from './load-context.mjs'
+
+const PRIORITIES = new Set(['P0', 'P1', 'P2', 'P3'])
+const SENSITIVE_KEY = /(?:authorization|cookie|password|secret|token|api[-_]?key|session[-_]?id)/i
+
+function slug(value) {
+  return String(value || 'review')
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 60) || 'review'
+}
+
+function assertNoSensitiveKeys(value, trail = []) {
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => assertNoSensitiveKeys(entry, [...trail, String(index)]))
+    return
+  }
+  if (!value || typeof value !== 'object') return
+  for (const [key, entry] of Object.entries(value)) {
+    if (SENSITIVE_KEY.test(key)) throw new Error(`critique input contains a forbidden sensitive field: ${[...trail, key].join('.')}`)
+    assertNoSensitiveKeys(entry, [...trail, key])
+  }
+}
+
+function validateReview(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error('critique input must be a JSON object')
+  if (!Number.isFinite(input.score) || input.score < 0 || input.score > 100) throw new Error('critique score must be between 0 and 100')
+  if (!Array.isArray(input.findings)) throw new Error('critique findings must be an array')
+  for (const [index, finding] of input.findings.entries()) {
+    if (!finding || typeof finding !== 'object') throw new Error(`finding ${index + 1} must be an object`)
+    if (!PRIORITIES.has(finding.priority)) throw new Error(`finding ${index + 1} has invalid priority`)
+    for (const field of ['title', 'evidence', 'recommendation']) {
+      if (typeof finding[field] !== 'string' || !finding[field].trim()) throw new Error(`finding ${index + 1} requires ${field}`)
+    }
+  }
+  assertNoSensitiveKeys(input)
+}
+
+function readInput(inputPath) {
+  const text = inputPath === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(path.resolve(inputPath), 'utf8')
+  if (Buffer.byteLength(text) > 1_000_000) throw new Error('critique input exceeds 1 MB')
+  return JSON.parse(text)
+}
+
+function counts(findings) {
+  const summary = { p0: 0, p1: 0, p2: 0, p3: 0 }
+  for (const finding of findings) summary[finding.priority.toLowerCase()]++
+  return summary
+}
+
+function markdown(review) {
+  const lines = [
+    `# Seven critique — ${review.target}`,
+    '',
+    `- Created: ${review.createdAt}`,
+    `- Seven release: ${review.release?.sevenVersion || 'unknown'}`,
+    `- Surface: ${review.surface || 'unresolved'}`,
+    `- Score: ${review.score}/100`,
+    `- Priorities: P0 ${review.summary.p0}, P1 ${review.summary.p1}, P2 ${review.summary.p2}, P3 ${review.summary.p3}`,
+    '',
+  ]
+  if (review.strengths?.length) {
+    lines.push('## Strengths to preserve', '')
+    for (const strength of review.strengths) lines.push(`- ${strength}`)
+    lines.push('')
+  }
+  lines.push('## Findings', '')
+  if (review.findings.length === 0) lines.push('No active findings.', '')
+  for (const finding of review.findings) {
+    lines.push(`### ${finding.priority} — ${finding.title}`, '')
+    lines.push(`**Evidence:** ${finding.evidence}`, '')
+    if (finding.impact) lines.push(`**Impact:** ${finding.impact}`, '')
+    if (finding.rootCause) lines.push(`**Root cause:** ${finding.rootCause}`, '')
+    lines.push(`**Direction:** ${finding.recommendation}`, '')
+    if (finding.verification) lines.push(`**Verify:** ${finding.verification}`, '')
+  }
+  if (review.verification) lines.push('## Verification evidence', '', review.verification, '')
+  lines.push('This review is evidence, not a visual authority. The installed Seven release remains canonical.', '')
+  return lines.join('\n')
+}
+
+function atomicWrite(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  const temporary = `${filePath}.tmp-${process.pid}-${Date.now()}`
+  fs.writeFileSync(temporary, content)
+  fs.renameSync(temporary, filePath)
+}
+
+export async function writeReview(start, target, input) {
+  validateReview(input)
+  const root = findRoot(start)
+  const context = await loadContext(root, { target })
+  let resolvedTarget = target
+  if (!/^https?:\/\//i.test(target)) {
+    const absolute = path.resolve(root, target)
+    const relative = path.relative(root, absolute)
+    if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error('critique target escapes the Seven project root')
+    resolvedTarget = relative.split(path.sep).join('/') || '.'
+  }
+  const createdAt = new Date().toISOString()
+  const review = {
+    schemaVersion: 1,
+    createdAt,
+    target: resolvedTarget,
+    surface: context.surface?.id || null,
+    release: context.release ? {
+      sevenVersion: context.release.sevenVersion,
+      skillVersion: context.release.skillVersion,
+      registrySha256: context.release.registrySha256,
+    } : null,
+    score: input.score,
+    summary: counts(input.findings),
+    renderedEvidence: input.renderedEvidence || null,
+    mechanicalEvidence: input.mechanicalEvidence || null,
+    strengths: Array.isArray(input.strengths) ? input.strengths : [],
+    findings: input.findings,
+    verification: input.verification || null,
+  }
+  const stamp = createdAt.replace(/[:.]/g, '-').replace(/-000Z$/, 'Z')
+  const base = path.join(root, '.seven', 'reviews', `${stamp}-${slug(context.surface?.id || resolvedTarget)}`)
+  atomicWrite(`${base}.json`, `${JSON.stringify(review, null, 2)}\n`)
+  atomicWrite(`${base}.md`, markdown(review))
+  return {
+    review,
+    json: path.relative(root, `${base}.json`).split(path.sep).join('/'),
+    markdown: path.relative(root, `${base}.md`).split(path.sep).join('/'),
+  }
+}
+
+export async function main(argv = process.argv) {
+  const action = argv[2]
+  if (action !== 'write') throw new Error('usage: critique-storage.mjs write --target <target> --input <review.json|->')
+  const target = argValue('--target', argv)
+  const inputPath = argValue('--input', argv)
+  if (!target || !inputPath) throw new Error('write requires --target and --input')
+  const result = await writeReview(process.cwd(), target, readInput(inputPath))
+  process.stdout.write(`${JSON.stringify({ json: result.json, markdown: result.markdown, summary: result.review.summary }, null, 2)}\n`)
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
+  main().catch((error) => {
+    process.stderr.write(`${error.message}\n`)
+    process.exitCode = 1
+  })
+}

package/.claude/skills/seven/scripts/load-context.mjs

@@ -1,84 +1,111 @@
 #!/usr/bin/env node
 // SPDX-License-Identifier: Apache-2.0
-// ETUS Digital — Seven Design System. Loader shape adapted from impeccable.
+// ETUS Digital — Seven consumer context adapter.
 
 import fs from 'node:fs'
 import path from 'node:path'
+import { createRequire } from 'node:module'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 
-const PRODUCT_NAMES = ['PRODUCT.md', 'Product.md', 'product.md']
-const DESIGN_NAMES = ['DESIGN.md', 'Design.md', 'design.md']
-const FALLBACK_DIRS = ['.agents/context', 'docs']
+import { checkForUpdate } from './update-check.mjs'
 
-function firstExisting(dir, names) {
-  for (const name of names) {
-    const abs = path.join(dir, name)
-    if (fs.existsSync(abs)) return abs
-  }
-  return null
+export function argValue(name, argv = process.argv) {
+  const direct = argv.find((arg) => arg.startsWith(`${name}=`))
+  if (direct) return direct.slice(name.length + 1)
+  const index = argv.indexOf(name)
+  return index >= 0 ? argv[index + 1] : null
 }
 
-function safeRead(filePath) {
+export function findRoot(start) {
+  let current = path.resolve(start)
   try {
-    return fs.readFileSync(filePath, 'utf8')
-  } catch {
-    return null
+    if (fs.statSync(current).isFile()) current = path.dirname(current)
+  } catch {}
+  const fallbackRoot = current
+  while (true) {
+    if (fs.existsSync(path.join(current, '.seven', 'project.yml'))) return current
+    if (fs.existsSync(path.join(current, 'seven.json'))) return current
+    const parent = path.dirname(current)
+    if (parent === current) break
+    current = parent
   }
+  return fallbackRoot
 }
 
-function resolveMaybeRelative(cwd, value) {
-  const trimmed = value.trim()
-  return path.isAbsolute(trimmed) ? trimmed : path.resolve(cwd, trimmed)
-}
-
-export function resolveContextDir(cwd = process.cwd()) {
-  const envDir = process.env.SEVEN_CONTEXT_DIR
-  if (envDir?.trim()) return resolveMaybeRelative(cwd, envDir)
-
-  if (firstExisting(cwd, [...PRODUCT_NAMES, ...DESIGN_NAMES])) return cwd
-
-  for (const rel of FALLBACK_DIRS) {
-    const candidate = path.resolve(cwd, rel)
-    if (firstExisting(candidate, [...PRODUCT_NAMES, ...DESIGN_NAMES])) return candidate
+export async function loadFromInstalledRuntime(root, target) {
+  try {
+    const require = createRequire(path.join(root, 'package.json'))
+    const manifest = require.resolve('@etus/seven/package.json')
+    const moduleUrl = pathToFileURL(path.join(path.dirname(manifest), 'lib', 'context.mjs')).href
+    const runtime = await import(moduleUrl)
+    return runtime.loadConsumerContext(root, { target })
+  } catch (error) {
+    return { runtimeError: error instanceof Error ? error.message : String(error) }
   }
-
-  return cwd
 }
 
-function extractRegister(product) {
-  if (!product) return null
-  const heading = product.match(/^##\s+Register\s*\n+([\s\S]*?)(?=\n##\s+|\s*$)/im)
-  const value = heading?.[1]?.split('\n').map((line) => line.trim()).find(Boolean)
-  if (!value) return null
-  return value.replace(/^[-*]\s*/, '').toLowerCase()
+export function fallback(root, target, runtimeError) {
+  const productPath = path.join(root, 'PRODUCT.md')
+  const product = fs.existsSync(productPath) ? fs.readFileSync(productPath, 'utf8') : null
+  let release = null
+  try {
+    release = JSON.parse(fs.readFileSync(path.join(root, '.seven', 'release.lock.json'), 'utf8'))
+  } catch {}
+  return {
+    schemaVersion: 1,
+    projectRoot: root,
+    target: path.resolve(target),
+    hasProduct: Boolean(product),
+    product,
+    productPath: product ? 'PRODUCT.md' : null,
+    productPlaceholder: !product || product.trim().length < 200 || /\b(?:TODO|TBD|placeholder)\b/i.test(product),
+    register: null,
+    project: null,
+    release,
+    surface: null,
+    runtimeAvailable: false,
+    runtimeError,
+  }
 }
 
-function isPlaceholderProduct(product) {
-  if (!product) return false
-  return product.trim().length < 200 || /\b(?:todo|tbd|placeholder|\[todo\])\b/i.test(product)
+export async function loadContext(start = process.cwd(), { target = start } = {}) {
+  const root = findRoot(start)
+  const loaded = await loadFromInstalledRuntime(root, target)
+  return loaded.runtimeError ? fallback(root, target, loaded.runtimeError) : loaded
 }
 
-export function loadContext(cwd = process.cwd()) {
-  const contextDir = resolveContextDir(cwd)
-  const productPath = firstExisting(contextDir, PRODUCT_NAMES)
-  const designPath = firstExisting(contextDir, DESIGN_NAMES)
-  const product = productPath ? safeRead(productPath) : null
-  const design = designPath ? safeRead(designPath) : null
-
+export function contextForAgent(context) {
+  const artifacts = context.release?.artifacts
+  if (!artifacts || typeof artifacts !== 'object') return context
+  const { artifacts: _artifacts, ...release } = context.release
+  const entries = Object.values(artifacts)
   return {
-    hasProduct: !!product,
-    product,
-    productPath: productPath ? path.relative(cwd, productPath) : null,
-    productPlaceholder: isPlaceholderProduct(product),
-    register: extractRegister(product),
-    hasDesign: !!design,
-    design,
-    designPath: designPath ? path.relative(cwd, designPath) : null,
-    contextDir,
+    ...context,
+    release: {
+      ...release,
+      artifactSummary: {
+        total: entries.length,
+        managed: entries.filter((entry) => entry?.kind === 'managed').length,
+        scaffold: entries.filter((entry) => entry?.kind === 'scaffold').length,
+      },
+    },
   }
 }
 
-function cli() {
-  process.stdout.write(`${JSON.stringify(loadContext(process.cwd()), null, 2)}\n`)
+export async function main(argv = process.argv) {
+  const target = argValue('--target', argv) || process.env.SEVEN_TARGET || process.cwd()
+  const context = await loadContext(target, { target })
+  const update = await checkForUpdate(context.release?.sevenVersion || null)
+  process.stdout.write(`${JSON.stringify({ ...contextForAgent(context), update }, null, 2)}\n`)
+}
+
+function isCliEntry() {
+  if (!process.argv[1]) return false
+  try {
+    return fs.realpathSync(fileURLToPath(import.meta.url)) === fs.realpathSync(process.argv[1])
+  } catch {
+    return false
+  }
 }
 
-if (process.argv[1]?.endsWith('load-context.mjs')) cli()
+if (isCliEntry()) await main()

package/.claude/skills/seven/scripts/run-seven.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+// ETUS Digital — package-manager-independent Seven CLI runner.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { createRequire } from 'node:module'
+import { fileURLToPath } from 'node:url'
+
+import { findRoot } from './load-context.mjs'
+
+export function resolveSevenCli(start = process.cwd()) {
+  const root = findRoot(start)
+  const require = createRequire(path.join(root, 'package.json'))
+  const manifestPath = require.resolve('@etus/seven/package.json')
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+  const bin = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.seven
+  if (!bin) throw new Error(`@etus/seven at ${manifestPath} does not declare the seven binary`)
+  return {
+    binPath: path.resolve(path.dirname(manifestPath), bin),
+    root,
+  }
+}
+
+export function runSeven(argv = process.argv.slice(2), start = process.cwd()) {
+  if (argv.length === 0) throw new Error('usage: run-seven.mjs <seven-command> [arguments]')
+  const { binPath, root } = resolveSevenCli(start)
+  const result = spawnSync(process.execPath, [binPath, ...argv], {
+    cwd: root,
+    env: process.env,
+    stdio: 'inherit',
+  })
+  if (result.error) throw result.error
+  return result.status ?? 1
+}
+
+function isCliEntry() {
+  if (!process.argv[1]) return false
+  try {
+    return fs.realpathSync(fileURLToPath(import.meta.url)) === fs.realpathSync(process.argv[1])
+  } catch {
+    return false
+  }
+}
+
+if (isCliEntry()) process.exitCode = runSeven()

package/.claude/skills/seven/scripts/update-check.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const DAY_MS = 24 * 60 * 60 * 1000
+const WEEK_MS = 7 * DAY_MS
+
+function cachePath(env = process.env) {
+  return env.SEVEN_UPDATE_CACHE || path.join(os.homedir(), '.seven', 'update-check.json')
+}
+
+function readCache(env) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(cachePath(env), 'utf8'))
+    return parsed && typeof parsed === 'object' ? parsed : {}
+  } catch {
+    return {}
+  }
+}
+
+function writeCache(cache, env) {
+  try {
+    const destination = cachePath(env)
+    fs.mkdirSync(path.dirname(destination), { recursive: true })
+    fs.writeFileSync(destination, `${JSON.stringify(cache, null, 2)}\n`)
+  } catch {
+    // Update discovery is best-effort and must never block the UI workflow.
+  }
+}
+
+function semverParts(value) {
+  const match = String(value || '').trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/)
+  if (!match) return null
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4] ? match[4].split('.') : [],
+  }
+}
+
+function compareIdentifier(left, right) {
+  const leftNumber = /^\d+$/.test(left) ? Number(left) : null
+  const rightNumber = /^\d+$/.test(right) ? Number(right) : null
+  if (leftNumber != null && rightNumber != null) return Math.sign(leftNumber - rightNumber)
+  if (leftNumber != null) return -1
+  if (rightNumber != null) return 1
+  return left.localeCompare(right)
+}
+
+export function compareSemver(left, right) {
+  const a = semverParts(left)
+  const b = semverParts(right)
+  if (!a || !b) return 0
+  for (let index = 0; index < 3; index++) {
+    if (a.core[index] !== b.core[index]) return Math.sign(a.core[index] - b.core[index])
+  }
+  if (a.prerelease.length === 0 && b.prerelease.length > 0) return 1
+  if (b.prerelease.length === 0 && a.prerelease.length > 0) return -1
+  for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index++) {
+    if (a.prerelease[index] == null) return -1
+    if (b.prerelease[index] == null) return 1
+    const compared = compareIdentifier(a.prerelease[index], b.prerelease[index])
+    if (compared !== 0) return compared
+  }
+  return 0
+}
+
+async function fetchLatest(env) {
+  const registry = (env.SEVEN_UPDATE_REGISTRY || 'https://registry.npmjs.org').replace(/\/$/, '')
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), 1500)
+  try {
+    const response = await fetch(`${registry}/%40etus%2Fseven/latest`, {
+      headers: { accept: 'application/json' },
+      signal: controller.signal,
+    })
+    if (!response.ok) return null
+    const payload = await response.json()
+    return typeof payload?.version === 'string' ? payload.version : null
+  } catch {
+    return null
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+export async function checkForUpdate(currentVersion, { env = process.env, now = Date.now() } = {}) {
+  if (!currentVersion || env.SEVEN_NO_UPDATE_CHECK) return null
+  const cache = readCache(env)
+  const fresh = typeof cache.checkedAt === 'number' && now - cache.checkedAt < DAY_MS
+  let latestVersion = fresh ? cache.latestVersion : await fetchLatest(env)
+  if (!latestVersion) latestVersion = cache.latestVersion || null
+  if (!fresh && latestVersion) {
+    cache.checkedAt = now
+    cache.latestVersion = latestVersion
+  }
+  if (!latestVersion) return null
+
+  const available = compareSemver(latestVersion, currentVersion) > 0
+  const notify = available && (
+    cache.notifiedVersion !== latestVersion ||
+    typeof cache.notifiedAt !== 'number' ||
+    now - cache.notifiedAt >= WEEK_MS
+  )
+  if (notify) {
+    cache.notifiedVersion = latestVersion
+    cache.notifiedAt = now
+  }
+  writeCache(cache, env)
+  return {
+    package: '@etus/seven',
+    currentVersion,
+    latestVersion,
+    available,
+    notify,
+    command: `pnpm add -D @etus/seven@${latestVersion} && pnpm exec seven update`,
+  }
+}

package/.claude-plugin/marketplace.json

@@ -11,8 +11,8 @@
   "plugins": [
     {
       "name": "seven",
-      "description": "Seven Design System skill, plugin, and CLI detector for AI coding agents — ETUS Digital",
-      "version": "0.1.0-beta.3",
+      "description": "Provider-native Seven Design System skills and deterministic UI detector runtime for @etus/seven consumers — ETUS Digital",
+      "version": "0.1.0-beta.5",
       "author": {
         "name": "ETUS Digital",
         "url": "https://github.com/etusdigital"

package/.claude-plugin/plugin.json

@@ -1,12 +1,17 @@
 {
   "name": "seven",
-  "description": "Seven Design System skill, plugin, and CLI detector for AI coding agents — ETUS Digital",
-  "version": "0.1.0-beta.3",
+  "description": "Provider-native Seven Design System skills and deterministic UI detector runtime for @etus/seven consumers — ETUS Digital",
+  "version": "0.1.0-beta.5",
   "author": {
     "name": "ETUS Digital",
     "url": "https://github.com/etusdigital"
   },
   "homepage": "https://github.com/etusdigital/seven#readme",
   "repository": "https://github.com/etusdigital/seven.git",
-  "skills": "./.claude/skills/"
+  "skills": "./.claude/skills/",
+  "agents": [
+    "./.claude/agents/seven-asset-producer.md",
+    "./.claude/agents/seven-finish-reviewer.md",
+    "./.claude/agents/seven-manual-edit-applier.md"
+  ]
 }