cyber-aced 0.3.0

package/skills/repair-private-skills/scripts/repair-private-skills.mts

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+// repair-private-skills — the concrete validate/repair engine for repo-private skill hygiene under
+// `.agents/skills`. Loaded in-session by the ACED `manage` gateway; not user-invocable.
+//
+// Checks each repo-private skill directory for two problems:
+//   - a stray symlink resolving into the public `skills/` tree (should be a real repo-private dir)
+//   - a SKILL.md missing `metadata.internal: true` in its YAML frontmatter
+// A directory holding only SKILL.local.md / SKILL.project.md (no SKILL.md) is an augmentation-only
+// entry and is never flagged.
+//
+// Operations:
+//   validate   read-only; reports issues; makes NO filesystem changes; nonzero exit when issues exist
+//   repair     writes fixes — deletes the stray symlink, inserts the missing metadata.internal: true
+//
+// Write boundary: repair writes/deletes ONLY under `.agents/skills` — it never creates, modifies, or
+// deletes anything under the public `skills/` tree. validate performs no writes at all.
+//
+// Pure functions are exported for node:test; running the file directly drives the CLI. No deps (the
+// repo's node-≥23.6 convention).
+
+import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from 'node:fs'
+import { join, sep } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+// ── shared shapes ──
+
+export interface RepairAction {
+	skill: string
+	action:
+		| 'removed_public_symlink'
+		| 'updated_metadata'
+		| 'already_internal'
+		| 'local_augmentation_only'
+		| 'skipped_missing_skill'
+		| 'skipped_no_frontmatter'
+	details?: string
+}
+
+export interface RepairResult {
+	changed: boolean
+	actions: RepairAction[]
+}
+
+export interface PrivateSkillIssue {
+	skill: string
+	issue: 'missing_metadata_internal' | 'public_skill_symlink' | 'missing_skill_file' | 'missing_frontmatter'
+	details?: string
+}
+
+export interface PrivateSkillCheckResult {
+	ok: boolean
+	issues: PrivateSkillIssue[]
+}
+
+// ── frontmatter metadata.internal: true insertion (pure — never touches disk) ──
+
+// Given a SKILL.md's raw content, returns whether metadata.internal: true is already present and,
+// if not, the content with it inserted (under an existing `metadata:` block or a new one appended
+// to the frontmatter). Content whose first line is not a `---` delimiter is returned unchanged.
+export function ensureInternalMetadata(content: string): { changed: boolean; content: string } {
+	const lines = content.split('\n')
+	if (lines[0]?.trim() !== '---') return { changed: false, content }
+
+	let endIndex = -1
+	for (let i = 1; i < lines.length; i++) {
+		if (lines[i]?.trim() === '---') {
+			endIndex = i
+			break
+		}
+	}
+	if (endIndex === -1) return { changed: false, content }
+
+	const frontmatter = lines.slice(1, endIndex)
+	let metadataIndex = -1
+	let metadataIndent = 0
+	let hasInternal = false
+
+	for (let i = 0; i < frontmatter.length; i++) {
+		const line = frontmatter[i] ?? ''
+		const metadataMatch = line.match(/^(\s*)metadata:\s*$/)
+		if (metadataMatch) {
+			metadataIndex = i
+			metadataIndent = metadataMatch[1]?.length ?? 0
+			for (let j = i + 1; j < frontmatter.length; j++) {
+				const nested = frontmatter[j] ?? ''
+				if (!nested.trim()) continue
+				const indent = nested.match(/^(\s*)/)?.[1]?.length ?? 0
+				if (indent <= metadataIndent) break
+				if (/^\s*internal:\s*true\s*$/i.test(nested)) hasInternal = true
+			}
+			break
+		}
+	}
+
+	if (hasInternal) return { changed: false, content }
+
+	if (metadataIndex >= 0) {
+		frontmatter.splice(metadataIndex + 1, 0, `${' '.repeat(metadataIndent + 2)}internal: true`)
+	} else {
+		frontmatter.push('metadata:', '  internal: true')
+	}
+
+	const updated = ['---', ...frontmatter, '---', ...lines.slice(endIndex + 1)].join('\n')
+	return { changed: true, content: updated }
+}
+
+// Resolve the public skills tree's real path (handles a symlinked ancestor, e.g. macOS
+// /var -> /private/var), falling back to the nominal path when it does not exist.
+function resolvePublicSkillsDir(root: string): string {
+	const publicSkillsDir = join(root, 'skills')
+	return existsSync(publicSkillsDir) ? realpathSync(publicSkillsDir) : publicSkillsDir
+}
+
+// True when a repo-private entry's resolved target lives inside (or equals) the public skills tree.
+function isPublicSkillSymlink(
+	skillDir: string,
+	entryName: string,
+	resolvedPublicSkillsDir: string,
+): { isSymlink: boolean; inPublicTree: boolean; resolved?: string } {
+	const stat = lstatSync(skillDir)
+	if (!stat.isSymbolicLink()) return { isSymlink: false, inPublicTree: false }
+	const resolved = realpathSync(skillDir)
+	const resolvedPublicSkillDir = join(resolvedPublicSkillsDir, entryName)
+	const inPublicTree = resolved === resolvedPublicSkillDir || resolved.startsWith(`${resolvedPublicSkillsDir}${sep}`)
+	return { isSymlink: true, inPublicTree, resolved }
+}
+
+// ── validate (read-only) ──
+
+// Checks every repo-private skill under `.agents/skills` and reports issues. Makes NO filesystem
+// changes — a missing `.agents/skills` directory is not an error (ok: true, no issues).
+export function validatePrivateSkills(root: string): PrivateSkillCheckResult {
+	const privateSkillsDir = join(root, '.agents', 'skills')
+	const issues: PrivateSkillIssue[] = []
+
+	if (!existsSync(privateSkillsDir)) return { ok: true, issues }
+
+	const resolvedPublicSkillsDir = resolvePublicSkillsDir(root)
+
+	for (const entry of readdirSync(privateSkillsDir, { withFileTypes: true })) {
+		const skillDir = join(privateSkillsDir, entry.name)
+
+		const symlinkCheck = isPublicSkillSymlink(skillDir, entry.name, resolvedPublicSkillsDir)
+		if (symlinkCheck.isSymlink && symlinkCheck.inPublicTree) {
+			issues.push({
+				skill: entry.name,
+				issue: 'public_skill_symlink',
+				details: `${skillDir} -> ${symlinkCheck.resolved}`,
+			})
+			continue
+		}
+
+		const skillFile = join(skillDir, 'SKILL.md')
+		if (!existsSync(skillFile)) {
+			if (existsSync(join(skillDir, 'SKILL.local.md')) || existsSync(join(skillDir, 'SKILL.project.md'))) continue
+			issues.push({ skill: entry.name, issue: 'missing_skill_file' })
+			continue
+		}
+
+		const original = readFileSync(skillFile, 'utf8')
+		if (original.split('\n')[0]?.trim() !== '---') {
+			issues.push({ skill: entry.name, issue: 'missing_frontmatter' })
+			continue
+		}
+
+		const metadata = ensureInternalMetadata(original)
+		if (metadata.changed) {
+			issues.push({ skill: entry.name, issue: 'missing_metadata_internal' })
+		}
+	}
+
+	return { ok: issues.length === 0, issues }
+}
+
+// ── repair (writes) ──
+
+// Fixes every repo-private skill under `.agents/skills`: deletes a stray public-tree symlink and
+// inserts a missing `metadata.internal: true`. Every write/delete this makes is confined to
+// `.agents/skills` — it never touches the public `skills/` tree.
+export function repairPrivateSkills(root: string): RepairResult {
+	const privateSkillsDir = join(root, '.agents', 'skills')
+	const actions: RepairAction[] = []
+	let changed = false
+
+	if (!existsSync(privateSkillsDir)) return { changed: false, actions }
+
+	const resolvedPublicSkillsDir = resolvePublicSkillsDir(root)
+
+	for (const entry of readdirSync(privateSkillsDir, { withFileTypes: true })) {
+		const skillDir = join(privateSkillsDir, entry.name)
+
+		const symlinkCheck = isPublicSkillSymlink(skillDir, entry.name, resolvedPublicSkillsDir)
+		if (symlinkCheck.isSymlink && symlinkCheck.inPublicTree) {
+			unlinkSync(skillDir)
+			actions.push({
+				skill: entry.name,
+				action: 'removed_public_symlink',
+				details: `${skillDir} -> ${symlinkCheck.resolved}`,
+			})
+			changed = true
+			continue
+		}
+
+		const skillFile = join(skillDir, 'SKILL.md')
+		if (!existsSync(skillFile)) {
+			if (existsSync(join(skillDir, 'SKILL.local.md')) || existsSync(join(skillDir, 'SKILL.project.md'))) {
+				actions.push({ skill: entry.name, action: 'local_augmentation_only' })
+				continue
+			}
+			actions.push({ skill: entry.name, action: 'skipped_missing_skill' })
+			continue
+		}
+
+		const original = readFileSync(skillFile, 'utf8')
+		if (original.split('\n')[0]?.trim() !== '---') {
+			actions.push({ skill: entry.name, action: 'skipped_no_frontmatter' })
+			continue
+		}
+
+		const updated = ensureInternalMetadata(original)
+		if (updated.changed) {
+			writeFileSync(skillFile, updated.content)
+			actions.push({ skill: entry.name, action: 'updated_metadata' })
+			changed = true
+		} else {
+			actions.push({ skill: entry.name, action: 'already_internal' })
+		}
+	}
+
+	return { changed, actions }
+}
+
+// ── CLI ──
+
+function flag(argv: string[], name: string): string | undefined {
+	const i = argv.indexOf(name)
+	return i === -1 ? undefined : argv[i + 1]
+}
+
+export function main(argv: string[]): number {
+	const root = flag(argv, '--root') ?? '.'
+	const json = flag(argv, '--format') === 'json'
+	const w = (s: string) => process.stdout.write(`${s}\n`)
+
+	if (argv.includes('validate')) {
+		const result = validatePrivateSkills(root)
+		if (json) {
+			w(JSON.stringify(result))
+		} else if (result.ok) {
+			w('ok: no issues found')
+		} else {
+			for (const issue of result.issues) {
+				w(`${issue.skill}: ${issue.issue}${issue.details ? ` (${issue.details})` : ''}`)
+			}
+		}
+		return result.ok ? 0 : 1
+	}
+
+	if (argv.includes('repair')) {
+		const result = repairPrivateSkills(root)
+		if (json) {
+			w(JSON.stringify(result))
+		} else if (!result.changed) {
+			w('no changes needed')
+		} else {
+			for (const action of result.actions) {
+				w(`${action.skill}: ${action.action}${action.details ? ` (${action.details})` : ''}`)
+			}
+		}
+		return 0
+	}
+
+	w('usage: repair-private-skills.mts [--root .] <validate|repair> [--format json]')
+	return 1
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
+	process.exit(main(process.argv.slice(2)))
+}

package/skills/report/README.md

@@ -0,0 +1,25 @@
+# report
+
+Generate a project-wide health dashboard across every ACED eval suite — pass rate, mean %max, trend vs. the previous run, and which agent configurations need attention.
+
+## When to use
+
+Use this skill when you want a status overview of ACED coverage across the whole project rather than a single suite.
+
+Good triggers include:
+
+- "How are our agent configs doing?" / "Give me an ACED health check"
+- Before a release, to confirm nothing has regressed unnoticed
+- Deciding what to work on next across many tracked skills/agents
+
+Defer to a sibling when the request is about one specific target: `run` to score it, `improve` to fix failures, `compare` to diff two versions.
+
+## What it does
+
+Scans the project spec (`.agents/specs/`) for behavioral-leaf nodes' `eval.md`, computes per-suite pass rate, mean %max (each scenario's total over its own maximum, normalized before averaging), and trend from the two most recent `results/` files, classifies each suite as healthy / degraded / critical / no-data / trending-down, and prints a dashboard with a "needs attention" list and suggested next action per suite.
+
+## Install
+
+```bash
+npx skills add cyberuni/cyberplace --skill aced/report
+```

package/skills/report/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: report
+description: Use this skill when the user wants a project-wide health summary of all ACED eval suites — pass rates, trends, and which agent configurations need attention.
+---
+
+# ACED Report
+
+Generate a project-wide health dashboard across all eval suites.
+
+## Discover eval suites
+
+Scan the project spec (`.agents/specs/`) for behavioral-leaf nodes carrying an `eval.md` (subject + run policy) alongside their `<node>.feature`. For each, read:
+- `eval.md` for target path and threshold
+- The most recent file in `results/` (sort by filename descending)
+- The second-most-recent file in `results/` for trend (if it exists)
+
+If no matching directories are found, report that no eval suites are initialized and suggest `sdd:start-mission` (the conductor resolves the ACED roles).
+
+## Compute per-suite metrics
+
+For each suite:
+- Pass rate (latest run)
+- Pass rate delta vs. previous run (trend)
+- Worst failing case: its name, and its total against **its own maximum** (`3/5 vs 4`)
+
+- Mean **%max** — the mean of each rubric scenario's `total ÷ its own maximum`, as a percentage
+
+**Never mean the raw totals.** Each scenario's rubric declares its own per-dimension maxima, so
+totals from different scenarios sit on different scales and averaging them measures nothing. Normalize
+first: `total ÷ max` per scenario, then mean those fractions. Always label the column `%max` so it is
+never read as a raw score. A suite with no rubric scenarios (all boolean or trigger) has no `%max` —
+render `—`.
+
+## Classify health
+
+| Status | Condition |
+|---|---|
+| `healthy` | Pass rate ≥ 90% |
+| `degraded` | Pass rate 70–89% |
+| `critical` | Pass rate < 70% |
+| `no-data` | No results file yet |
+| `trending-down` | Pass rate dropped ≥ 10% vs. previous run |
+
+## Report
+
+```
+ACED Project Report
+═══════════════════════════════════════════════
+
+  Suite                  Status       Pass   Mean %max   Trend
+  ───────────────────────────────────────────────────────────
+  commit-discipline      healthy      95%    92%         ↑ +5%
+  create-skill           degraded     76%    74%         → 0%
+  aced-case-judge        critical     58%    61%         ↓ -12%
+  subagents/researcher   no-data       —      —          —
+
+NEEDS ATTENTION:
+  ✗ aced-case-judge (critical, trending down) — run aced-improve
+      worst: red tests block the commit  1/5 vs 4  (correctness 0/3, completeness 1/2)
+  ⚠ create-skill (degraded) — run run for details
+
+Suites with no results: subagents/researcher — run run to initialize
+```
+
+## Optional: full detail mode
+
+If the user asks for details on a specific suite, print all failing cases from the latest result file with their per-dimension scores, their total against its maximum, the threshold, and the case's `what_failed`.
+
+## Suggest next actions
+
+- For `critical` or `trending-down`: suggest `improve`
+- For `degraded`: suggest `run` for details, then `improve`
+- For `no-data`: suggest `run`
+- For all `healthy` with no trend data: suggest `add-scenario` to expand coverage

package/skills/run/README.md

@@ -0,0 +1,25 @@
+# run
+
+Run the frozen `.feature` suite for one target agent configuration and report pass rate and per-dimension scores, and per-scenario results.
+
+## When to use
+
+Use this skill when you want to score a skill, subagent, command, or AGENTS.md section against its frozen `.feature` suite — typically right after editing it.
+
+Good triggers include:
+
+- "Run the evals for this skill"
+- "Score this agent config"
+- Checking whether a config still passes after an edit, before deciding whether to `improve` or `compare`
+
+Defer to a sibling when the request is about diagnosing failures (`improve`), diffing two versions (`compare`), adding a new case (`add-scenario`), or a project-wide summary (`report`).
+
+## What it does
+
+Locates the target's `eval.md` and frozen `.feature`, invokes `aced-case-judge` once per scenario (skipping layers not enabled in `eval.md`'s `eval.layers`), computes the pass rate and each case's per-dimension total against its own maximum / per-layer breakdown, writes a timestamped JSON result file, and reports a summary with the worst-scoring failures first.
+
+## Install
+
+```bash
+npx skills add cyberuni/cyberplace --skill aced/run
+```

package/skills/run/SKILL.md

@@ -0,0 +1,220 @@
+---
+name: run
+description: Use this skill when running ACED evals to score agent configuration behavior against its frozen .feature suite — after editing a skill, AGENTS.md section, subagent, or command.
+---
+
+# ACED Run
+
+Run the frozen `.feature` suite for a target agent configuration and report results. The `.feature`
+is the single eval source — scenarios, inline `@rubric` criteria, and `@trigger` `Examples` all live
+in it. `eval.md` carries only the subject binding and run policy.
+
+## Locate the suite
+
+If the user specifies a target, find the target's node in the project spec —
+`.agents/specs/<project>/…/<node>/` (discovered through the SDD spec tree; the node's `eval.md` names
+the subject) — which holds the frozen `<node>.feature` and its colocated `eval.md` (subject + run
+policy). If no target is specified and only one node in the project spec carries an `eval.md`, use it.
+If multiple exist, ask which to run. **If no suite exists at all, report that no eval suite is
+initialized and stop — do not run.**
+
+Read `eval.md` for the **measurement policy** (two-level shape):
+
+- `subject` — the agent configuration under test.
+- `eval.layers` — which layers run (`trigger` / `behavior` / `quality`).
+- `eval.judge.model` and `eval.judge.default_threshold` — the scoring engine + fallback threshold.
+- `eval.trigger.{activation_threshold, runs}` — the trigger-layer run policy.
+
+Read the `subject` agent configuration in full before evaluating — the judge needs the current version.
+
+## Run each scenario
+
+Enumerate the scenarios of `<feature-name>.feature` **in file order**. For each scenario:
+
+1. Determine its layer from its tag (`@trigger` / `@behavior` / `@quality`); a scenario with no layer
+   tag defaults to `behavior`.
+2. **Skip** the scenario if its layer is not listed in `eval.layers`.
+3. Extract the eval from the scenario itself:
+   - `@rubric` scenario → the inline rubric docstring (dimensions + per-dimension `max` + `threshold`);
+     an inline `threshold` overrides `eval.judge.default_threshold`.
+   - `@trigger` `Scenario Outline` → each `Examples` row is one case; invoke the judge **once per row**, passing its zero-based `ROW`.
+   - a deterministic boolean scenario → its boolean `Then` assertions.
+4. Invoke `aced-case-judge` with the `subject`, the **`.feature` path and the scenario name** (plus the
+   `ROW` for a trigger outline), and its threshold, over the run count for its layer
+   (`eval.trigger.runs` for trigger; else a single behavior/quality run unless the caller sets N).
+5. Collect, by shape: a `@rubric` case returns a score per named dimension against that dimension's
+   own `max`, plus the total and pass/fail (pass = total ≥ threshold; a triggered must-not-do is a
+   fail outright). A trigger row returns its invoke decision against the expected one — accuracy is
+   yours to aggregate across rows and runs, against `eval.trigger.activation_threshold`. A boolean
+   scenario returns pass/fail with no dimension scores. Every shape also returns `WHAT WORKED` and
+   `WHAT FAILED` — those two are the whole explanation the judge emits, and it emits nothing else.
+
+Run all scenarios before reporting. Do not stop on first failure.
+
+## Invoking aced-case-judge
+
+Pass this context block to the judge:
+
+```
+SUBJECT:
+<full agent configuration text>
+
+FEATURE_PATH: <path to the frozen .feature>
+SCENARIO: <exact scenario name>
+ROW: <zero-based Examples row — trigger outlines only>
+LAYER: <layer>
+THRESHOLD: <inline threshold, else eval.judge.default_threshold>
+```
+
+**Pass the path and the name — never the steps, the `Then`, or the rubric.** The judge simulates and
+scores in two separate contexts and composes the simulating context's brief with the
+`extract-situation` engine; handing it the scenario body would put the answer key back in the
+context that has to reach the answer. One invocation covers both passes — never sequence them here.
+
+**Wait for each judge, and bank only its last word.** The dispatch is asynchronous, and the judge is
+itself waiting on its own blind simulator — so it can report before its measurement exists and
+correct itself afterwards. Where an agent reports more than once, the **final** report for that agent
+id supersedes the earlier one entirely: never bank the first, never merge them. Do not compute
+results while any judge is still live; a run that ends with cases outstanding reports those cases as
+**unmeasured**, not as passes or failures. A judge that emits `BLOCKER: <reason>` in place of a score
+is likewise unmeasured — surface it rather than folding it into the pass rate.
+
+## Compute results
+
+After all scenarios:
+
+- Pass rate = passing scenarios / total scenarios
+- Per-layer breakdown (trigger pass rate, behavior pass rate)
+- Failing scenarios sorted by **margin** (`total − threshold`) ascending, worst first
+
+Report each scenario's total **against its own maximum** (`4/5`), never as a bare number. Maxima
+differ per scenario, so a mean taken across raw totals compares scales that do not line up — if you
+report a headline number, report the mean **margin** or the mean **fraction of maximum**, and say
+which.
+
+## Record what was evaluated
+
+Before writing the record, list **every input you consumed to judge this target** — the target
+configuration, each file it loads, the target's `eval.md`, the frozen `.feature`, and any directory
+you **listed** to find those files. This is what makes a recorded result checkable later:
+`check-freshness` re-hashes exactly these paths and nothing else, so a result whose provenance is
+missing or wrong is worse than one carrying none.
+
+**Record only what you actually consumed.** A file you did not open does not belong in the set —
+this is not "everything next to the config". Over-reporting is visible against a fixture and will
+fail the suite; it also makes every later freshness answer wrong in the direction of `stale`.
+
+Compute each hash with the **shared engine**, never by hand and never with a second implementation.
+`<aced-skills>` is the directory **containing** this skill (`run`'s parent), so the engine resolves as
+the sibling `check-freshness`:
+
+```bash
+node "<aced-skills>/check-freshness/scripts/check-freshness.mts" --hash-file <repo-relative path>
+node "<aced-skills>/check-freshness/scripts/check-freshness.mts" --hash-dir  <repo-relative path>
+```
+
+`check-freshness` compares using that same routine. Two schemes that merely agree today would
+surface their divergence as a permanent `stale` rather than as an error, so there is one routine and
+both sides call it.
+
+| Entry `kind` | What the hash covers | Why |
+|---|---|---|
+| `file` | the bytes of the content you read | a content change must be detectable; a timestamp must never stand in for one |
+| `directory` | the **names** the listing returned (sorted, `\n`-joined) | this is what makes a file later **added** to that directory detectable without re-resolving the subject |
+
+**An entry carries no modification time** — not as a hash, and not alongside one. A recorded mtime
+invites a reader to compare it, and a file rewritten with identical bytes would then read as changed.
+
+**Record each `path` repo-relative, and run the engine from the repository root.** The reader
+resolves every entry against the repo root, so an absolute path is silently unverifiable. The engine
+resolves its argument against the current directory — invoked from elsewhere it can hash a
+same-named file somewhere else and record a right-looking path over a wrong digest.
+
+**A directory you expanded needs BOTH**: the directory entry *and* a `file` entry for each file that
+listing yielded. The directory hash covers names only, so it is invariant under a content edit
+inside it — without the per-file entries, editing a file the subject loads from a references
+directory would read as `current` forever.
+
+## Record the model that scored the run
+
+Record **the model you dispatched `aced-case-judge` under** — as you can name it, and `unknown`
+exactly when you cannot. That is one condition, not a combination of several:
+
+- You dispatched under the `eval.md` `judge.model` → record that value.
+- You dispatched under a different model (a caller named one, or the policy was overridden) → record
+  **the model you dispatched under**, never the declaration you did not honor.
+- You cannot name the model you dispatched under → record `unknown`, whatever `eval.md` declares.
+
+**`unknown` is a value, never an omitted field.** A missing field and a recorded `unknown` make
+different claims, and a reader grouping results by model has to tell a run nobody attributed from one
+attributed to a named model.
+
+**It goes beside the scores, never inside `evaluated`.** The evaluated set is inputs whose bytes get
+re-hashed; a model has none, so recording it there hands `check-freshness` a member it could only
+ever report as unverifiable. The `eval.md` that *declares* the model is already in the set — what
+this field adds is which model actually ran.
+
+**One model per record.** It is a property of the run that produced these scores, not of the target:
+two runs for one target under different models each carry their own, which is what keeps a target's
+results groupable by model.
+
+## Write results
+
+Write to `.agents/aced/results/<target-slug>/<ISO8601-timestamp>.json` — the shared, git-ignored ACED results directory at the repo root, keyed by the target (a filesystem-safe slug of the target agent-configuration path), not scattered under each project-spec directory:
+
+```json
+{
+  "timestamp": "<ISO8601>",
+  "target": "<agent configuration path>",
+  "pass_rate": 0.82,
+  "scoring_model": "<the model you dispatched the judge under, or \"unknown\">",
+  "evaluated": [
+    { "path": "<agent configuration path>", "sha256": "<hex>", "kind": "file" },
+    { "path": "<a directory the config loads from>", "sha256": "<hex>", "kind": "directory" },
+    { "path": "<each file that listing yielded>", "sha256": "<hex>", "kind": "file" },
+    { "path": "<the target eval.md>", "sha256": "<hex>", "kind": "file" },
+    { "path": "<the frozen .feature>", "sha256": "<hex>", "kind": "file" }
+  ],
+  "scenarios": [
+    {
+      "name": "<scenario name>",
+      "layer": "behavior",
+      "dimensions": [
+        { "name": "correctness", "score": 2, "max": 3 },
+        { "name": "completeness", "score": 1, "max": 2 }
+      ],
+      "total": 3,
+      "max": 5,
+      "threshold": 4,
+      "pass": false,
+      "what_worked": "...",
+      "what_failed": "..."
+    }
+  ]
+}
+```
+
+A `@trigger` row carries `"row"`, `"invoke"`, `"expected"`, and `"pass"` instead of `"dimensions"`; a
+boolean scenario carries `"pass"` alone.
+
+## Report to user
+
+```
+ACED Run — <name>
+──────────────────────────
+Pass rate:  18/22 (82%)
+
+Trigger layer:  8/10 (80%)
+Behavior layer: 10/12 (83%)
+
+FAILING SCENARIOS (worst first):
+  ✗ no trigger for an audit request   [invoked: no, expected: yes] — <what failed>
+  ✗ stages only related files         [3/5 vs 4: correctness 2/3, completeness 1/2] — <what failed>
+  ✗ trigger on skill creation         [invoked: yes, expected: no] — <what failed>
+  ✗ red tests block the commit        [3/5 vs 4: correctness 1/3, completeness 2/2] — <what failed>
+
+Run improve to address failing scenarios.
+Run compare after editing the agent configuration.
+```
+
+If pass rate is 100%, say so and suggest running `add-scenario` to expand edge case coverage.

package/skills/skillify/README.md

@@ -0,0 +1,25 @@
+# skillify
+
+Generalize a workflow from the current session into a reusable `SKILL.md`.
+
+## When to use
+
+Use this skill when a multi-step workflow was just completed and should be encoded for reuse.
+
+Good triggers include:
+
+- "Skillify this"
+- "Make this reusable"
+- "Turn what we just did into a skill"
+
+Different from `aced:define-skill`, which scaffolds from a blank template — this skill analyzes what actually happened in the session.
+
+## What it does
+
+The skill extracts trigger, decisions, steps, inputs, and outputs from session history, then drafts a focused skill following skill-design governance. It validates with `audit validate` before linking or committing.
+
+## Install
+
+```bash
+npx skills add cyberuni/cyberplace --skill skillify
+```