@amsterdamdatalabs/enact-extensions 0.1.12 → 0.1.25

package/extensions/enact-core/hooks/hooks.json

@@ -1,5 +1,17 @@
 {
   "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "enact-extensions hook session-start",
+            "statusMessage": "Checking plugin freshness"
+          }
+        ]
+      }
+    ],
     "UserPromptSubmit": [
       {
         "hooks": [

package/extensions/enact-evolve/.agents/plugin.json

@@ -0,0 +1,47 @@
+{
+  "name": "enact-evolve",
+  "version": "0.1.0",
+  "description": "Session evidence analysis plugin for enact-evolve ingestion, evaluation, and synthesis workflows.",
+  "author": {
+    "name": "Amsterdam Data Labs"
+  },
+  "homepage": "https://amsterdamdatalabs.com",
+  "repository": "https://dev.azure.com/amsterdamdatalabs/Enact/_git/enact-extensions",
+  "license": "UNLICENSED",
+  "keywords": [
+    "enact-evolve",
+    "session-analysis",
+    "transcripts",
+    "evidence",
+    "evaluation",
+    "synthesis"
+  ],
+  "targets": [
+    "claude",
+    "codex",
+    "cursor",
+    "enact"
+  ],
+  "skills": "./skills/",
+  "agents": "./agents/",
+  "interface": {
+    "displayName": "Enact Evolve",
+    "shortDescription": "CLI-backed session evidence ingestion, evaluation, and synthesis workflows.",
+    "longDescription": "Install this plugin to make enact-evolve the default path for Codex, Claude, and Factory session forensics: ingest transcripts, evaluate normalized evidence, and synthesize human-readable findings without running promotion.",
+    "developerName": "Amsterdam Data Labs",
+    "category": "Developer Tools",
+    "composerIcon": "./assets/icon.png",
+    "logo": "./assets/logo.png",
+    "capabilities": [
+      "session transcript ingestion",
+      "evidence evaluation",
+      "forensics synthesis",
+      "candidate improvement review",
+      "context usage analysis"
+    ]
+  },
+  "factory": {
+    "firstParty": true,
+    "operatorScope": "global"
+  }
+}

package/extensions/enact-evolve/agents/evolve-session-analyst.toml

@@ -0,0 +1,37 @@
+name = "evolve-session-analyst"
+desc = "Session forensics agent that must run enact-evolve ingest/evaluate before synthesis"
+model = "gpt-5.5"
+claude_model = "opus"
+cursor_model = "default"
+model_reasoning_effort = "medium"
+sandbox_mode = "danger-full-access"
+developer_instructions = """
+Agent definition: enact-evolve session forensics analyst.
+
+Use this agent when a user asks to analyze a Codex, Claude, or Factory session transcript, rollout JSONL, hook/tool behavior, context injection, token/context burn, or why an agent did not use the expected evolve workflow.
+
+Core rules:
+- Use enact-evolve artifacts as primary truth.
+- Start with the session-analysis skill workflow and run the bundled run-evolve-analysis.sh helper unless the user explicitly provides already-generated evidence and eval artifacts.
+- Run enact-evolve ingest and enact-evolve evaluate before synthesizing findings.
+- Never run enact-evolve promote.
+- Do not create downstream Dream, wiki, extension, package patch, or promotion handoff artifacts.
+- Treat the current working directory as the project/workspace storage anchor, matching Enact plugin and MCP `mcp .` conventions.
+- Use raw transcript JSONL only as a clearly labeled cross-check for details not yet normalized by enact-evolve, such as exact MCP server/tool pairs or hook execution gaps.
+- If normalized evidence has an empty hook_summary or hook_timeline, report that as an evidence limitation instead of claiming hooks did not fire.
+- Prefer absolute artifact paths in the final report.
+
+Analysis process:
+1. Identify surface and session source.
+2. Produce or locate session-specific evidence output.
+3. Read session-evidence.jsonl, eval/metrics.jsonl, eval/candidate-improvements.jsonl, eval/trace-events.jsonl, and the transcript markdown.
+4. Cross-check raw transcript only for missing normalized fields requested by the user.
+5. Synthesize a concise report covering identity, pipeline proof, tool/MCP behavior, hook evidence, context injection, token/context usage, candidates, and actionable findings.
+
+Output contract:
+- evidence_artifacts
+- normalized_findings
+- raw_cross_checks
+- synthesis
+- follow_up_recommendations
+"""

package/extensions/enact-evolve/skills/session-analysis/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: session-analysis
+description: This skill should be used when the user asks to analyze, audit, evaluate, or synthesize Codex, Claude, or Factory session transcripts, rollout JSONL files, tool/MCP call behavior, hook evidence, context injection, token usage, or candidate improvements with enact-evolve. It must run enact-evolve ingest and evaluate before drawing conclusions and must not run promotion.
+argument-hint: "--surface <codex|claude|factory> --session <path-or-id> [--watchdog <path>] [--out <dir>]"
+---
+
+# Enact Evolve Session Analysis
+
+Use this workflow for session forensics. The purpose is to force the product path first: `enact-evolve ingest` then `enact-evolve evaluate`, then synthesis from generated artifacts.
+
+## Non-Negotiables
+
+- Use `enact-evolve` CLI artifacts as primary truth.
+- Never run `enact-evolve promote`.
+- Do not create Dream, wiki, extension, package patch, or promotion handoff artifacts.
+- Do not rely on raw JSONL parsing until after ingest/evaluate has run.
+- Label every raw transcript lookup as a cross-check, not primary evidence.
+- If `hook_summary` or `hook_timeline` is empty, say the normalized evidence did not capture hook firings; do not infer that hooks did not fire.
+
+## Inputs
+
+Accept the same arguments as the helper script:
+
+```bash
+${CLAUDE_PLUGIN_ROOT}/skills/session-analysis/scripts/run-evolve-analysis.sh \
+  --surface codex \
+  --session /path/to/session.jsonl
+```
+
+Required:
+- `--surface codex|claude|factory`
+- `--session <path-or-id>`
+
+Optional:
+- `--watchdog <path>`
+- `--out <dir>`
+
+Default output:
+`~/.enact/evolve/projects/<workspace-id>/analysis/<surface>-<safe-session-id>/`
+
+The helper resolves `<workspace-id>` from the current working directory by calling `enact-evolve storage --json`, matching the cwd-bound `mcp .` pattern used by other Enact plugins. Pass `--out` only when an explicit non-default location is required.
+
+## Workflow
+
+1. Resolve the session source and surface.
+   - Use `codex` for files under `.codex/sessions` or rollout JSONL.
+   - Use `claude` for Claude transcript JSONL.
+   - Use `factory` only for supported factory scenarios.
+   - Treat the current working directory as the owning workspace for storage.
+
+2. Run the helper script.
+   - Prefer the bundled script over handwritten CLI command sequences.
+   - The script verifies `enact-evolve`, resolves project-scoped analysis storage from cwd, writes session-specific artifacts, and refuses to continue if promotion artifacts are produced.
+
+3. Read these generated artifacts:
+   - `session-evidence.jsonl`
+   - `metrics.jsonl`
+   - `candidate-improvements.jsonl`
+   - `trace-events.jsonl`
+   - `eval/session-evidence.jsonl`
+   - `eval/metrics.jsonl`
+   - `eval/candidate-improvements.jsonl`
+   - `eval/trace-events.jsonl`
+   - `<session-id>.md`
+   - `synthesis.md`
+
+4. Synthesize from normalized evidence first.
+   - Use `tool_summary`, `tool_timeline`, `hook_summary`, `hook_timeline`, `context_summary`, `system_prompts`, `quality_metrics`, and `candidate_improvements`.
+   - Prefer the transcript markdown for readable chronology and context.
+   - Use raw JSONL only for fields that are not yet represented in normalized evidence, such as exact MCP `server/tool` pairs.
+
+5. Report limitations.
+   - Empty hook summaries mean "not normalized/captured as hook events in evidence", not "did not happen."
+   - Missing prompt counts or context entries should be called out as evidence-shape limitations.
+   - If the helper fails because `enact-evolve` is missing, report the install/runtime issue before attempting manual analysis.
+
+## Required Synthesis Shape
+
+Return or update `synthesis.md` with these sections:
+
+- `Session Identity`: surface, session id, source path, evidence id, output paths.
+- `Pipeline Proof`: exact ingest/evaluate commands and generated artifact list.
+- `Tool And MCP Analysis`: normalized tool summary first; raw MCP cross-check only if needed.
+- `Hook Evidence`: hook timeline/summary and any explicit evidence limitation.
+- `Context Injection`: system/developer/context entries, token usage, duplicate context, largest context blocks.
+- `Candidate Summary`: counts by target family, notable source signals, extension-skill/rule/tool-description implications.
+- `Findings`: what happened, what went wrong, and what the assistant should have done.
+- `Follow-Up Recommendations`: implementation or workflow changes, explicitly excluding promotion unless the user separately requests it.
+
+## Verification
+
+After running the helper, verify:
+- `session-evidence.jsonl` exists and has at least one record.
+- `eval/metrics.jsonl` exists.
+- `eval/candidate-improvements.jsonl` exists, even if empty.
+- Transcript markdown exists.
+- `synthesis.md` exists.
+- No `promote/` directory exists under the output directory.

package/extensions/enact-evolve/skills/session-analysis/scripts/run-evolve-analysis.sh

@@ -0,0 +1,343 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'USAGE'
+Usage:
+  run-evolve-analysis.sh --surface codex|claude|factory --session <path-or-id> [--watchdog <path>] [--out <dir>]
+
+Runs enact-evolve ingest, enact-evolve evaluate, and writes synthesis.md.
+This workflow does not run promotion.
+USAGE
+}
+
+surface=""
+session=""
+watchdog=""
+out=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --surface)
+      surface="${2:-}"
+      shift 2
+      ;;
+    --session)
+      session="${2:-}"
+      shift 2
+      ;;
+    --watchdog)
+      watchdog="${2:-}"
+      shift 2
+      ;;
+    --out)
+      out="${2:-}"
+      shift 2
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      usage >&2
+      exit 2
+      ;;
+  esac
+done
+
+if [[ -z "$surface" || -z "$session" ]]; then
+  usage >&2
+  exit 2
+fi
+
+case "$surface" in
+  codex|claude|factory)
+    ;;
+  *)
+    echo "Invalid --surface: $surface" >&2
+    usage >&2
+    exit 2
+    ;;
+esac
+
+if ! command -v enact-evolve >/dev/null 2>&1; then
+  echo "enact-evolve is required on PATH." >&2
+  exit 127
+fi
+
+safe_session_id() {
+  local value="$1"
+  value="${value%/}"
+  value="${value##*/}"
+  value="${value:-session}"
+  printf '%s' "$value" | sed -E 's/[^A-Za-z0-9._-]+/-/g; s/^-+//; s/-+$//'
+}
+
+safe_id="$(safe_session_id "$session")"
+if [[ -z "$out" ]]; then
+  storage_json="$(enact-evolve storage --json)" || {
+    echo "Unable to resolve project-scoped enact-evolve storage from the current working directory. Run inside a project, or pass --out." >&2
+    exit 1
+  }
+  analysis_root="$(python3 -c 'import json, sys; print(json.load(sys.stdin).get("analysis_dir", ""))' <<< "$storage_json")"
+  if [[ -z "$analysis_root" ]]; then
+    echo "enact-evolve storage --json did not return analysis_dir." >&2
+    exit 1
+  fi
+  out="${analysis_root}/${surface}-${safe_id}"
+  if [[ -e "${out}/session-evidence.jsonl" ]]; then
+    out="${out}-$(date -u +%Y%m%dT%H%M%SZ)"
+  fi
+fi
+
+mkdir -p "$out"
+
+if [[ "$surface" == "factory" ]]; then
+  ingest_cmd=(enact-evolve ingest --surface "$surface" --scenario "$session" --out "$out")
+else
+  ingest_cmd=(enact-evolve ingest --surface "$surface" --session "$session" --out "$out")
+fi
+
+if [[ -n "$watchdog" ]]; then
+  ingest_cmd+=(--watchdog "$watchdog")
+fi
+
+evaluate_cmd=(enact-evolve evaluate --evidence "${out}/session-evidence.jsonl" --out "${out}/eval")
+
+{
+  printf 'ingest: '
+  printf '%q ' "${ingest_cmd[@]}"
+  printf '\n'
+  printf 'evaluate: '
+  printf '%q ' "${evaluate_cmd[@]}"
+  printf '\n'
+} > "${out}/pipeline-commands.txt"
+
+"${ingest_cmd[@]}"
+"${evaluate_cmd[@]}"
+
+python3 - "$out" "$surface" "$session" <<'PY'
+import collections
+import json
+import sys
+from pathlib import Path
+
+out = Path(sys.argv[1]).expanduser().resolve()
+surface = sys.argv[2]
+session_arg = sys.argv[3]
+
+def read_jsonl(path):
+    path = Path(path)
+    if not path.exists():
+        return []
+    text = path.read_text(encoding="utf-8").strip()
+    if not text:
+        return []
+    if text.startswith("["):
+        data = json.loads(text)
+        return data if isinstance(data, list) else [data]
+    rows = []
+    for line in text.splitlines():
+        line = line.strip()
+        if line:
+            rows.append(json.loads(line))
+    return rows
+
+def first_present(mapping, keys, default=None):
+    cur = mapping
+    for key in keys:
+        if not isinstance(cur, dict) or key not in cur:
+            return default
+        cur = cur[key]
+    return cur
+
+def fmt_count_map(counter):
+    if not counter:
+        return "- None"
+    items = counter.items() if hasattr(counter, "items") else counter
+    return "\n".join(f"- `{key}`: {value}" for key, value in sorted(items))
+
+def compact_json(value, limit=600):
+    if value in (None, "", [], {}):
+        return "None"
+    text = json.dumps(value, ensure_ascii=False, sort_keys=True)
+    if len(text) > limit:
+        return text[: limit - 3] + "..."
+    return text
+
+def bullet_lines(items, limit=20, key=None):
+    if not items:
+        return "- None"
+    lines = []
+    for item in items[:limit]:
+        if key and isinstance(item, dict):
+            value = item.get(key)
+            count = item.get("count")
+            if count is not None:
+                lines.append(f"- `{value}`: {count}")
+            else:
+                lines.append(f"- `{value}`")
+        elif isinstance(item, dict):
+            lines.append(f"- `{compact_json(item, 360)}`")
+        else:
+            lines.append(f"- `{item}`")
+    if len(items) > limit:
+        lines.append(f"- ... {len(items) - limit} more")
+    return "\n".join(lines)
+
+evidence_rows = read_jsonl(out / "session-evidence.jsonl")
+metrics_rows = read_jsonl(out / "metrics.jsonl")
+candidate_rows = read_jsonl(out / "candidate-improvements.jsonl")
+trace_rows = read_jsonl(out / "trace-events.jsonl")
+eval_metrics_rows = read_jsonl(out / "eval" / "metrics.jsonl")
+eval_candidate_rows = read_jsonl(out / "eval" / "candidate-improvements.jsonl")
+
+evidence = evidence_rows[-1] if evidence_rows else {}
+quality_metrics = evidence.get("quality_metrics") or {}
+context_usage = quality_metrics.get("context_usage") or {}
+token_usage = quality_metrics.get("token_usage") or {}
+context_summary = evidence.get("context_summary") or []
+context_entries = evidence.get("context_entries") or []
+tool_summary = evidence.get("tool_summary") or []
+tool_timeline = evidence.get("tool_timeline") or []
+hook_summary = evidence.get("hook_summary") or []
+hook_timeline = evidence.get("hook_timeline") or []
+system_prompts = evidence.get("system_prompts") or []
+candidate_source = eval_candidate_rows or candidate_rows
+candidate_counts = collections.Counter(
+    (row.get("target_family") or "unknown") for row in candidate_source if isinstance(row, dict)
+)
+source_signal_counts = collections.Counter()
+for row in candidate_source:
+    if not isinstance(row, dict):
+        continue
+    for signal in row.get("source_signals") or []:
+        source_signal_counts[str(signal)] += 1
+
+artifact_paths = []
+for path in sorted(out.rglob("*")):
+    if path.is_file():
+        artifact_paths.append(path.relative_to(out).as_posix())
+
+transcripts = [
+    path for path in sorted(out.glob("*.md"))
+    if path.name != "synthesis.md"
+]
+
+commands = (out / "pipeline-commands.txt").read_text(encoding="utf-8").strip()
+session_id = evidence.get("session_id") or Path(session_arg).name
+evidence_id = evidence.get("evidence_id") or evidence.get("id") or "unknown"
+source_refs = evidence.get("source_refs") or []
+source_path = evidence.get("source_path") or evidence.get("source") or (source_refs[0] if source_refs else session_arg)
+
+top_context_sources = context_usage.get("top_context_sources") or []
+largest_context_blocks = context_usage.get("largest_context_blocks") or context_usage.get("largest_blocks") or []
+duplicate_context_count = context_usage.get("duplicate_context_count")
+if duplicate_context_count is None:
+    duplicate_context_count = context_usage.get("duplicate_count", "not normalized")
+
+tool_family_counts = collections.Counter()
+for item in tool_summary:
+    if isinstance(item, dict):
+        name = item.get("name") or item.get("tool") or item.get("kind") or item.get("key") or "unknown"
+        tool_family_counts[str(name)] += int(item.get("count") or 1)
+
+markdown = f"""# Enact Evolve Session Analysis
+
+## Session Identity
+
+- Surface: `{surface}`
+- Session id: `{session_id}`
+- Source path: `{source_path}`
+- Evidence id: `{evidence_id}`
+- Output directory: `{out}`
+- Transcript markdown: `{transcripts[0] if transcripts else 'not generated'}`
+
+## Pipeline Proof
+
+```text
+{commands}
+```
+
+Generated artifacts:
+{bullet_lines(artifact_paths, limit=80)}
+
+## Tool And MCP Analysis
+
+Normalized tool summary:
+{bullet_lines(tool_summary, limit=30)}
+
+Tool timeline entries: `{len(tool_timeline)}`
+
+Tool family counts:
+{fmt_count_map(tool_family_counts)}
+
+Raw MCP cross-check: not performed by this helper. Use the original JSONL only when normalized evidence lacks a requested exact server/tool pair, and label that lookup as a cross-check.
+
+## Hook Evidence
+
+Normalized hook summary:
+{bullet_lines(hook_summary, limit=30)}
+
+Hook timeline entries: `{len(hook_timeline)}`
+
+Evidence limitation: {"normalized evidence did not capture hook firings for this transcript; inspect raw JSONL only as a labeled cross-check for hook execution gaps." if not hook_summary and not hook_timeline else "hook evidence is present in normalized artifacts."}
+
+## Context Injection
+
+- System prompt entries: `{len(system_prompts)}`
+- Context entries: `{len(context_entries)}`
+- Context usage: `{compact_json(context_usage, 1200)}`
+- Context summary: `{compact_json(context_summary, 1200)}`
+- Token usage: `{compact_json(token_usage, 1200)}`
+- Duplicate context count: `{duplicate_context_count}`
+
+Top context sources:
+{bullet_lines(top_context_sources, limit=20)}
+
+Largest context blocks:
+{bullet_lines(largest_context_blocks, limit=20)}
+
+## Candidate Summary
+
+Candidate rows: `{len(candidate_source)}`
+
+Counts by target family:
+{fmt_count_map(candidate_counts)}
+
+Top source signals:
+{fmt_count_map(source_signal_counts.most_common(20))}
+
+Extension implications: review candidates targeting skill instructions, hook rules, tool descriptions, and agent routing. Keep promotion out of this plugin workflow unless a separate user request explicitly starts a downstream promotion process.
+
+## Findings
+
+- The canonical workflow ran through `enact-evolve ingest` and `enact-evolve evaluate` before synthesis.
+- Findings should be grounded in normalized evidence first; raw transcript inspection is only a cross-check for missing normalized fields.
+- If hook evidence is empty above, the actionable issue is normalizer coverage, not proof that hooks did not execute.
+- If the original assistant analyzed raw JSONL without this pipeline, the follow-up is to route session-forensics requests through this skill and helper first.
+
+## Follow-Up Recommendations
+
+- Add or improve evolve normalization for exact MCP server/tool pairs if users routinely ask for that level of detail.
+- Add hook event normalization coverage when transcripts contain hook execution records that do not appear in `hook_summary` or `hook_timeline`.
+- Use candidate target families and source signals to decide whether follow-up work belongs in extension skills, hook rules, or tool descriptions.
+- Keep this plugin CLI-only until `enact-evolve` exposes a real MCP command.
+"""
+
+(out / "synthesis.md").write_text(markdown, encoding="utf-8")
+PY
+
+if [[ -d "${out}/promote" ]]; then
+  echo "Unexpected promotion artifacts found under ${out}/promote" >&2
+  exit 1
+fi
+
+cat <<EOF
+analysis_out=${out}
+session_evidence=${out}/session-evidence.jsonl
+eval_metrics=${out}/eval/metrics.jsonl
+eval_candidates=${out}/eval/candidate-improvements.jsonl
+synthesis=${out}/synthesis.md
+EOF

package/extensions/enact-factory/.agents/plugin.json

@@ -18,11 +18,11 @@
   "targets": [
     "claude",
     "codex",
-    "cursor"
+    "cursor",
+    "enact"
   ],
   "skills": "./skills/",
   "agents": "./agents/",
-  "hooks": "./hooks/hooks.json",
   "mcpServers": "./.mcp.json",
   "validate": "enact-factory doctor",
   "interface": {

package/extensions/enact-factory/agents/architect.toml

@@ -1,14 +1,18 @@
 name = "architect"
 description = "Architectural review and GO/NO-GO verdict with evidence pointers — independent grader"
+model = "gpt-5.5"
+claude_model = "opus"
+cursor_model = "default"
 model_reasoning_effort = "high"
 sandbox_mode = "danger-full-access"
 tools = "Read, Grep, Glob, Bash"
 developer_instructions = """
-You are the Enact Loop architect agent. You are an INDEPENDENT GRADER.
+Agent definition: read-only architectural reviewer and independent grader for GO/NO-GO verdicts with evidence pointers.
 
-You run on a different model and vendor from the executor. You must reach your own GO/NO-GO verdict
-independently — do not defer to the executor's self-assessment. Your verdict is recorded by
-`loop_grader_verdict` and is required before the judgment stage can close.
+You run on a different model and vendor from the executor. Reach your own GO/NO-GO verdict
+independently — do not defer to the executor's self-assessment. Return a verdict envelope to the
+driver (default) or call `loop_grader_verdict` directly with the dispatch-minted continuationId.
+You have NO closure authority — do not call loop_complete, summary write, pause/resume, or retarget.
 
 Role:
 - Read-only architectural reviewer.
@@ -20,7 +24,7 @@ Rules:
 - Never speculate when you can read the source.
 - Cite exact file paths and line references for material claims.
 - Call out tradeoffs, not just the favored direction.
-- Record your verdict via loop_grader_verdict — do not self-report on behalf of the executor.
+- Return verdict envelope to driver (captureSource=relayed) or call loop_grader_verdict directly with continuationId from dispatch. No closure tools.
 
 Output contract:
 - verdict: GO or NO-GO

package/extensions/enact-factory/agents/code-reviewer.toml

@@ -1,14 +1,18 @@
 name = "code-reviewer"
 description = "Binding code review pass — independent grader on a separate model"
+model = "gpt-5.3-codex-spark"
+claude_model = "haiku"
+cursor_model = "default"
 model_reasoning_effort = "high"
 sandbox_mode = "danger-full-access"
 tools = "Read, Grep, Glob, Bash"
 developer_instructions = """
-You are the Enact Loop code-reviewer agent. You are an INDEPENDENT GRADER.
+Agent definition: binding code review pass — independent grader on a separate model.
 
-You run on a different model and vendor from the executor. You must reach your own verdict
-independently — do not defer to the executor's self-assessment. Your verdict is recorded by
-`loop_grader_verdict` and is required before the judgment stage can close.
+You run on a different model and vendor from the executor. Reach your own verdict
+independently — do not defer to the executor's self-assessment. Return a verdict envelope to the
+driver (default) or call `loop_grader_verdict` directly with the dispatch-minted continuationId.
+You have NO closure authority — do not call loop_complete, summary write, pause/resume, or retarget.
 
 Role:
 - Perform the binding review pass after an implementation batch.
@@ -20,7 +24,7 @@ Rules:
 - Every finding must cite a file reference and explain impact.
 - If no actionable issues remain, emit the token UNCONDITIONAL_APPROVE.
 - Otherwise, return a blocking verdict with the findings ordered by severity.
-- Record your verdict via loop_grader_verdict — do not self-report on behalf of the executor.
+- Return verdict envelope to driver (captureSource=relayed) or call loop_grader_verdict directly with continuationId from dispatch. No closure tools.
 
 Output contract:
 - verdict: UNCONDITIONAL_APPROVE or REQUEST_CHANGES

package/extensions/enact-factory/agents/critic.toml

@@ -1,14 +1,18 @@
 name = "critic"
 description = "Adversarial debate participant for high-risk decision review — independent grader"
+model = "gpt-5.3-codex-spark"
+claude_model = "haiku"
+cursor_model = "default"
 model_reasoning_effort = "high"
 sandbox_mode = "danger-full-access"
 tools = "Read, Grep, Glob, Bash"
 developer_instructions = """
-You are the Enact Loop critic agent. You are an INDEPENDENT GRADER.
+Agent definition: adversarial debate participant for high-risk decision review — independent grader.
 
-You run on a different model and vendor from the executor. You must reach your own GO/NO-GO verdict
-independently — do not defer to the executor's self-assessment. Your verdict is recorded by
-`loop_grader_verdict` and is required before the judgment stage can close.
+You run on a different model and vendor from the executor. Reach your own GO/NO-GO verdict
+independently — do not defer to the executor's self-assessment. Return a verdict envelope to the
+driver (default) or call `loop_grader_verdict` directly with the dispatch-minted continuationId.
+You have NO closure authority — do not call loop_complete, summary write, pause/resume, or retarget.
 
 Role:
 - Attack weak assumptions in plans, proposals, and risky implementation choices.
@@ -19,7 +23,7 @@ Rules:
 - Surface the strongest counterargument first.
 - Prefer concrete failure modes over vague concern language.
 - When a decision looks sound, say that plainly instead of inventing objections.
-- Record your GO/NO-GO verdict via loop_grader_verdict — do not self-report on behalf of the executor.
+- Return verdict envelope to driver (captureSource=relayed) or call loop_grader_verdict directly with continuationId from dispatch. No closure tools.
 
 Round protocol:
 1. Independent critique.

package/extensions/enact-factory/agents/executor.toml

@@ -1,9 +1,12 @@
 name = "executor"
 description = "Focused implementation worker for small, reviewable diffs with verification"
+model = "gpt-5.4"
+claude_model = "sonnet"
+cursor_model = "composer-2.5"
 model_reasoning_effort = "medium"
 sandbox_mode = "danger-full-access"
 developer_instructions = """
-You are the Enact Loop executor agent.
+Agent definition: focused implementation worker for small, reviewable diffs with verification.
 
 Role:
 - Implement the requested change with the smallest viable diff.