@ketecode/loom 0.1.0 → 0.2.0

package/hooks/read-before-edit/cases.json

@@ -0,0 +1,15 @@
+{
+  "should_block": [
+    { "files": [{ "path": "package.json", "content": "{}" }] },
+    { "files": [{ "path": "README.md", "content": "x" }] },
+    { "files": [{ "path": "bin/kete-loom.js", "content": "x" }] },
+    { "files": [{ "path": "scripts/lib/lint.js", "content": "x" }] },
+    { "files": [{ "path": "brand-new-file.ts", "content": "x" }, { "path": "AGENTS.md", "content": "x" }] }
+  ],
+  "should_allow": [
+    { "files": [{ "path": "src/does-not-exist-yet.ts", "content": "x" }] },
+    { "files": [{ "path": "notes/new-plan.md", "content": "x" }] },
+    { "files": [{ "path": "package.json", "content": "{}" }] },
+    { "files": [{ "path": "README.md", "content": "y" }] }
+  ]
+}

package/hooks/read-before-edit/hook.js

@@ -0,0 +1,50 @@
+'use strict';
+
+// Refuses the first edit of each existing file per session, telling the agent to read it and search for
+// its callers, then allows the retry. check({ files: [{ path }], cwd, session }) -> verdict.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const KEEP_MS = 2 * 24 * 60 * 60 * 1000;
+
+const stateFile = () => path.join(process.env.KETE_LOOM_STATE_DIR || path.join(os.homedir(), '.kete-loom', 'state'), 'read-before-edit.json');
+
+function load(file, now) {
+  try {
+    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    for (const k of Object.keys(data)) if (!(now - data[k] < KEEP_MS)) delete data[k];
+    return data;
+  } catch {
+    return {};
+  }
+}
+
+function check(event, now = Date.now()) {
+  const cwd = path.resolve(event.cwd || process.cwd());
+  const scope = event.session || `${cwd}@${new Date(now).toISOString().slice(0, 10)}`;
+  const file = stateFile();
+  const seen = load(file, now);
+  const fresh = [];
+  for (const f of event.files || []) {
+    if (!f || typeof f.path !== 'string') continue;
+    const abs = path.resolve(cwd, f.path);
+    const key = `${scope}\n${abs}`;
+    if (!seen[key] && fs.existsSync(abs)) fresh.push(path.relative(cwd, abs) || abs);
+    seen[key] = now;
+  }
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(seen));
+  } catch {
+    return { block: false }; // can't remember the refusal, so refusing would block forever
+  }
+  if (!fresh.length) return { block: false };
+  return {
+    block: true,
+    reason: `kete-loom (read-before-edit): before changing ${fresh.map((p) => `\`${p}\``).join(', ')}, read the whole file and search the codebase for what imports, calls or configures it. Then make the same edit again; it will go through.`,
+  };
+}
+
+module.exports = { check };

package/hooks/run.js

@@ -7,10 +7,13 @@
 // dependencies.
 //
 // Events: pre-shell { command, cwd }, pre-edit { files: [{ path, content }], cwd },
-// post-edit { files: [{ path }], cwd }, session-start { cwd }.
+// post-edit { files: [{ path }], cwd }, session-start { cwd }, stop and stop-gate { cwd, again } when
+// the agent finishes its turn. Every event also carries `session` when the host sends a session id.
 //
 // Blocking (pre-*): exit 2 with the reason on stderr works on every host; Cursor and Copilot also get
-// their JSON verdict. Internal errors fail OPEN (exit 0): Copilot and Kete Code deny on a crashed hook,
+// their JSON verdict. stop-gate blocks by making the agent continue with the reason as its next
+// prompt (exit 2 on Claude Code, Codex and Gemini CLI; JSON on Cursor and Copilot); `again` is true
+// when this turn was itself continued by a stop hook, so a gate can let it end instead of looping. Internal errors fail OPEN (exit 0): Copilot and Kete Code deny on a crashed hook,
 // so a runner bug must never block every tool call. post-edit and session-start never block.
 
 const fs = require('fs');
@@ -59,20 +62,22 @@ function normalize(host, event, j) {
   const cwd = pick(j, 'cwd') || (Array.isArray(j.workspace_roots) && j.workspace_roots[0]) || process.env.CURSOR_PROJECT_DIR || process.cwd();
   const tool = j.tool || j.toolName || j.tool_name;
   const toolArgs = () => (host === 'copilot' ? parseMaybe(j.toolArgs) : j.tool_input || j.args || {});
-  if (event === 'session-start') return { cwd };
+  const session = pick(j, 'session_id', 'sessionId', 'conversation_id');
+  if (event === 'session-start') return { cwd, session };
+  if (event === 'stop' || event === 'stop-gate') return { cwd, session, again: j.stop_hook_active === true || j.loop_count > 0 };
   if (SHELL_TOOLS[host] && event === 'pre-shell' && tool && !SHELL_TOOLS[host].includes(tool)) return null;
   if (EDIT_TOOLS[host] && event !== 'pre-shell' && tool && !EDIT_TOOLS[host].includes(tool)) return null;
 
   if (event === 'pre-shell') {
     const command = host === 'cursor' ? j.command : pick(toolArgs(), 'command');
-    return typeof command === 'string' ? { command, cwd } : null;
+    return typeof command === 'string' ? { command, cwd, session, background: toolArgs().run_in_background === true } : null;
   }
   let files;
   if (host === 'codex') files = parsePatch(pick(j.tool_input, 'command', 'input', 'patch'));
   else if (host === 'cursor') files = j.file_path ? [{ path: j.file_path, content: '' }] : [];
   else if (host === 'claude' || host === 'gemini') files = claudeFiles(j.tool_input);
   else files = looseFiles(toolArgs());
-  return files.length ? { files, cwd } : null;
+  return files.length ? { files, cwd, session } : null;
 }
 
 const SESSION_JSON = {
@@ -89,7 +94,13 @@ const DENY_JSON = {
   copilot: (reason) => ({ permissionDecision: 'deny', permissionDecisionReason: reason }),
 };
 
-const EVENTS = ['pre-shell', 'pre-edit', 'post-edit', 'session-start'];
+// How each host is told to keep going instead of ending the turn.
+const CONTINUE_JSON = {
+  cursor: (reason) => ({ followup_message: reason }),
+  copilot: (reason) => ({ decision: 'block', reason }),
+};
+
+const EVENTS = ['pre-shell', 'pre-edit', 'post-edit', 'session-start', 'stop', 'stop-gate'];
 const allow = (host, event) => ({ code: 0, stdout: event.startsWith('pre-') && ALLOW_JSON[host] ? JSON.stringify(ALLOW_JSON[host]) : '', stderr: '' });
 
 // Returns { code, stdout, stderr } so tests can drive it without a process.
@@ -110,6 +121,11 @@ function respond(host, hookName, input, hooksDir = __dirname, event = 'pre-shell
   if (event === 'session-start') {
     return verdict.context && SESSION_JSON[host] ? { code: 0, stdout: JSON.stringify(SESSION_JSON[host](String(verdict.context))), stderr: '' } : allow(host, event);
   }
+  if (event === 'stop-gate' && verdict.block) {
+    const reason = String(verdict.reason || `Continue: kete-loom hook ${hookName} asked for more work`);
+    if (CONTINUE_JSON[host]) return { code: 0, stdout: JSON.stringify(CONTINUE_JSON[host](reason)), stderr: '' };
+    return { code: 2, stdout: '', stderr: `${reason}\n` };
+  }
   if (!event.startsWith('pre-') || !verdict.block) return allow(host, event);
   const reason = String(verdict.reason || `Blocked by kete-loom hook ${hookName}`);
   return { code: 2, stdout: DENY_JSON[host] ? JSON.stringify(DENY_JSON[host](reason)) : '', stderr: `${reason}\n` };

package/hooks/verify-before-stop/HOOK.md

@@ -0,0 +1,32 @@
+---
+name: verify-before-stop
+description: When the agent says it is done, runs the project's own lint and type-check commands if files changed, and sends it back to fix any failure instead of letting it finish with broken code.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: testing
+  kete-loom/risk: runs-commands
+  kete-loom/event: "stop-gate"
+  kete-loom/opt-in: "true"
+  kete-loom/owner: "Kete-org"
+---
+
+# Verify before stop
+
+Runs when the agent ends its turn, in a git repository only.
+
+If the working tree has changed code files, it runs the checks the project already defines:
+
+| Project | Checks |
+|---|---|
+| `package.json` | the `typecheck` / `type-check` / `check-types` script and the `lint` script, run with the package manager the lockfile belongs to |
+| Python | `ruff check` on the changed `.py` files, when Ruff is configured and installed |
+| Go | `go vet ./...` |
+
+If a check fails, the turn does not end. The agent gets the failing command and the end of its output, and is told to fix the cause, not the check. It is sent back only once in a row, so a check it can't fix never traps it in a loop.
+
+Tests are not run, because they can take far longer than a hook should. Use the `/verify` command or the `verification-loop` skill for that. Each check is limited to 75 seconds. Nothing is installed and nothing is changed.
+
+Available in Claude Code, Codex, Gemini CLI, Cursor and GitHub Copilot. Kete Code's and OpenCode's stop hooks can't send the agent back to work.
+
+Opt-in: `--hooks` leaves it out; install it by name with `--hook` or with `--profile strict`.

package/hooks/verify-before-stop/hook.js

@@ -0,0 +1,70 @@
+'use strict';
+
+// When the agent ends its turn with changed code, runs the project's own lint and type-check commands
+// and sends it back to fix failures. check({ cwd, again }) -> verdict.
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync, spawnSync } = require('child_process');
+
+const TIMEOUT_MS = 75000;
+const CODE = /\.(?:[cm]?[jt]sx?|vue|svelte|astro|py|go|json)$/;
+
+const git = (cwd, args) => {
+  try {
+    return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 });
+  } catch {
+    return null;
+  }
+};
+
+function onPath(bin) {
+  const exts = process.platform === 'win32' ? (process.env.PATHEXT || '.EXE;.CMD').split(';') : [''];
+  for (const dir of (process.env.PATH || '').split(path.delimiter)) for (const ext of exts) if (dir && fs.existsSync(path.join(dir, bin + ext))) return true;
+  return false;
+}
+
+// [label, program, args] for each check the project defines.
+function checksFor(root, changed) {
+  const checks = [];
+  const has = (f) => fs.existsSync(path.join(root, f));
+  let pkg = null;
+  try {
+    pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+  } catch {
+    // no package.json
+  }
+  const scripts = (pkg && pkg.scripts) || {};
+  const pm = has('pnpm-lock.yaml') ? 'pnpm' : has('yarn.lock') ? 'yarn' : has('bun.lock') || has('bun.lockb') ? 'bun' : 'npm';
+  for (const name of [['typecheck', 'type-check', 'check-types'].find((s) => scripts[s]), scripts.lint && 'lint'].filter(Boolean)) {
+    checks.push([`${pm} run ${name}`, pm, ['run', name]]);
+  }
+  const py = changed.filter((f) => f.endsWith('.py'));
+  const ruffConfigured = has('ruff.toml') || has('.ruff.toml') || /\[tool\.ruff/.test(has('pyproject.toml') ? fs.readFileSync(path.join(root, 'pyproject.toml'), 'utf8') : '');
+  if (py.length && ruffConfigured && onPath('ruff')) checks.push([`ruff check ${py.join(' ')}`, 'ruff', ['check', ...py]]);
+  if (changed.some((f) => f.endsWith('.go')) && has('go.mod') && onPath('go')) checks.push(['go vet ./...', 'go', ['vet', './...']]);
+  return checks;
+}
+
+function check(event) {
+  if (event.again) return { block: false };
+  const cwd = event.cwd || process.cwd();
+  const root = (git(cwd, ['rev-parse', '--show-toplevel']) || '').trim();
+  if (!root) return { block: false };
+  const changed = (git(root, ['status', '--porcelain', '--untracked-files=all']) || '')
+    .split('\n').filter(Boolean).map((l) => l.slice(3).replace(/^.* -> /, '').replace(/^"|"$/g, ''))
+    .filter((f) => CODE.test(f) && fs.existsSync(path.join(root, f)));
+  if (!changed.length) return { block: false };
+  for (const [label, program, args] of checksFor(root, changed)) {
+    const r = spawnSync(program, args, { cwd: root, encoding: 'utf8', timeout: TIMEOUT_MS, shell: process.platform === 'win32' });
+    if (r.error || r.status === 0) continue; // a check that can't start or times out says nothing about the code
+    const tail = `${r.stdout || ''}${r.stderr || ''}`.trim().split('\n').slice(-30).join('\n').slice(-2500);
+    return {
+      block: true,
+      reason: `kete-loom (verify-before-stop): \`${label}\` fails with your changes. Fix the cause in the code (don't weaken the check), run it again, and only then finish.\n\n${tail}`,
+    };
+  }
+  return { block: false };
+}
+
+module.exports = { check, checksFor };

package/mcp/clickhouse.json

@@ -0,0 +1,11 @@
+{
+  "name": "clickhouse",
+  "description": "ClickHouse Cloud's remote MCP server: list databases and tables and run read-only SQL on services you enable it for, signed in with ClickHouse Cloud OAuth.",
+  "version": "0.1.0",
+  "category": "data",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.clickhouse.cloud/mcp",
+  "auth": "oauth",
+  "homepage": "https://clickhouse.com/docs/cloud/features/ai-ml/remote-mcp"
+}

package/mcp/exa.json

@@ -0,0 +1,11 @@
+{
+  "name": "exa",
+  "description": "Exa's remote MCP server: web search, page contents and code search for the model. Free and rate-limited without a key; no sign-in needed.",
+  "version": "0.1.0",
+  "category": "docs",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.exa.ai/mcp",
+  "auth": "none",
+  "homepage": "https://exa.ai/docs/reference/exa-mcp"
+}

package/mcp/firecrawl.json

@@ -0,0 +1,11 @@
+{
+  "name": "firecrawl",
+  "description": "Firecrawl's remote MCP server: scrape, crawl, map and search websites into clean Markdown or structured data, signed in with Firecrawl OAuth.",
+  "version": "0.1.0",
+  "category": "data",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.firecrawl.dev/v2/mcp-oauth",
+  "auth": "oauth",
+  "homepage": "https://docs.firecrawl.dev/mcp-server"
+}

package/mcp/vercel.json

@@ -0,0 +1,11 @@
+{
+  "name": "vercel",
+  "description": "Vercel's remote MCP server: search the docs, manage projects and deployments, read deployment logs and query Web Analytics, signed in with Vercel OAuth.",
+  "version": "0.1.0",
+  "category": "devops",
+  "risk": "network",
+  "transport": "http",
+  "url": "https://mcp.vercel.com",
+  "auth": "oauth",
+  "homepage": "https://vercel.com/docs/agent-resources/vercel-mcp"
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ketecode/loom",
-  "version": "0.1.0",
-  "description": "Kete Loom: curated, tested, portable Agent Skills, subagents, commands, rules, hooks and MCP configs. One source, installable in Claude Code, Codex, OpenCode, Cursor, Gemini CLI, GitHub Copilot and Kete Code.",
+  "version": "0.2.0",
+  "description": "Kete Loom: curated, tested, portable Agent Skills, subagents, commands, rules, hooks and MCP configs. One source, installable in Claude Code, Codex, OpenCode, Cursor, Gemini CLI, GitHub Copilot, Kete Code and Kiro.",
   "license": "MIT",
   "author": "Kete-org <support@ketecode.ai>",
   "homepage": "https://ketecode.ai",
@@ -19,7 +19,8 @@
     "cursor",
     "gemini-cli",
     "copilot",
-    "kete-code"
+    "kete-code",
+    "kiro"
   ],
   "bin": {
     "kete-loom": "bin/kete-loom.js"
@@ -46,9 +47,10 @@
   },
   "scripts": {
     "lint": "node scripts/lint-skills.js",
-    "eval": "node scripts/run-evals.js",
+    "eval": "node scripts/run-evals.js && node scripts/run-behavior-evals.js",
     "eval:estimate": "node scripts/run-evals.js --estimate",
     "eval:live": "node scripts/run-evals.js --live",
+    "eval:behavior": "node scripts/run-behavior-evals.js",
     "test": "node --test",
     "check": "npm run lint && npm test && npm run eval",
     "catalog": "node scripts/build-catalog.js",

package/profiles.json

@@ -66,6 +66,52 @@
       "guard-secrets"
     ]
   },
+  "strict": {
+    "description": "Developer plus the opt-in guardrails: read files before editing them, don't weaken lint configs, keep dev servers in the background, and pass lint and type-check before finishing.",
+    "extends": [
+      "developer"
+    ],
+    "hooks": [
+      "read-before-edit",
+      "protect-lint-config",
+      "block-foreground-servers",
+      "verify-before-stop"
+    ]
+  },
+  "method": {
+    "description": "A full development method: design before code, granular plans, a fresh subagent per task with spec and quality review, systematic debugging, rigorous responses to review, worktrees and a clean finish.",
+    "skills": [
+      "design-brainstorming",
+      "implementation-plans",
+      "subagent-driven-development",
+      "systematic-debugging",
+      "tdd-workflow",
+      "verification-loop",
+      "responding-to-code-review",
+      "git-worktrees",
+      "finishing-a-branch"
+    ],
+    "agents": [
+      "planner",
+      "task-implementer",
+      "spec-reviewer",
+      "code-reviewer"
+    ],
+    "commands": [
+      "brainstorm",
+      "plan-feature",
+      "feature-dev",
+      "debug",
+      "verify",
+      "review",
+      "finish-branch"
+    ],
+    "rules": [
+      "use-skills",
+      "common",
+      "testing"
+    ]
+  },
   "security": {
     "description": "Security and compliance: every security and compliance item, the essentials, and the four safety hooks.",
     "extends": [
@@ -120,16 +166,18 @@
     ]
   },
   "full": {
-    "description": "Everything in Kete Loom, including every hook.",
+    "description": "Everything in Kete Loom, with every hook that isn't opt-in (add those with --hook or the strict profile).",
     "all": true
   },
   "mcp-web": {
-    "description": "MCP pack for web work: Playwright and Chrome DevTools browsers, Context7 library docs and Fetch.",
+    "description": "MCP pack for web work: Playwright and Chrome DevTools browsers, Context7 library docs, Fetch, Exa web search and Firecrawl scraping.",
     "mcp": [
       "playwright",
       "chrome-devtools",
       "context7",
-      "fetch"
+      "fetch",
+      "exa",
+      "firecrawl"
     ]
   },
   "mcp-code": {
@@ -149,11 +197,12 @@
     ]
   },
   "mcp-cloud": {
-    "description": "MCP pack for cloud and payments: Cloudflare, Supabase (read-only) and Stripe.",
+    "description": "MCP pack for cloud and payments: Cloudflare, Vercel, Supabase (read-only) and Stripe.",
     "mcp": [
       "cloudflare",
       "supabase",
-      "stripe"
+      "stripe",
+      "vercel"
     ]
   },
   "mcp-design": {

package/rules/use-skills.md

@@ -0,0 +1,23 @@
+---
+name: use-skills
+description: Always-on rule to check for an installed skill, agent or command that fits a task before starting it, say which one is used, and follow its steps rather than working from memory.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: meta
+  kete-loom/risk: read-only
+  kete-loom/owner: "Kete-org"
+---
+
+- Before starting a task, including a clarifying question or a quick look at the code, check whether an installed skill, agent or command covers it. Check again when the task changes.
+- If one fits even partly, load it and tell the user in one line which one you are using and why.
+- Prefer the most specific match: a framework skill over a language skill, a language reviewer over a general one.
+- Process skills (brainstorming, debugging, test-first, planning) come before implementation skills; they decide how the work is done.
+- Follow a loaded skill's steps in order. Do not skip a step because you remember the gist or the task looks simple.
+- Where a skill has a checklist, work through every item and report each one.
+- Treat a skill's "stop and ask" points as real stops; do not guess past them.
+- Read a skill's `references/` files when its steps tell you to, not from memory of similar files.
+- Delegate to an agent when its description matches and its separate context helps (reviews, wide searches, build fixes).
+- If no skill fits, say so briefly and work normally; do not force a poor match.
+- The user's explicit instructions win over any skill. When they conflict, follow the user and mention the conflict once.
+- Never claim to have followed a skill you did not load.

package/scripts/lib/behavior.js

@@ -0,0 +1,52 @@
+'use strict';
+
+// Behaviour evals: evals/behavior.json in a skill or agent folder. Each scenario is a user request
+// (often with pressure to skip the item's discipline), optional files the agent can see, and what the
+// reply must and must not show. scripts/run-behavior-evals.js runs them with and without the item.
+
+const fs = require('fs');
+const path = require('path');
+
+const PRESSURES = ['time', 'sunk-cost', 'authority', 'exhaustion', 'social', 'pragmatism', 'small-scope'];
+const MIN_SCENARIOS = 2;
+
+const behaviorFile = (item) => path.join(item.path, 'evals', 'behavior.json');
+
+// Returns null when the item has no behavior.json, else { scenarios, problems }.
+function loadBehavior(item) {
+  const file = behaviorFile(item);
+  if (!fs.existsSync(file)) return null;
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (e) {
+    return { scenarios: [], problems: [`evals/behavior.json is not valid JSON: ${e.message}`] };
+  }
+  return { scenarios: Array.isArray(data.scenarios) ? data.scenarios : [], problems: validate(data) };
+}
+
+function validate(data) {
+  const problems = [];
+  const list = data && Array.isArray(data.scenarios) ? data.scenarios : null;
+  if (!list) return ['evals/behavior.json needs a "scenarios" array'];
+  if (list.length < MIN_SCENARIOS) problems.push(`evals/behavior.json needs at least ${MIN_SCENARIOS} scenarios`);
+  const names = new Set();
+  list.forEach((s, i) => {
+    const at = `scenario ${i + 1}${s && typeof s.name === 'string' ? ` "${s.name}"` : ''}`;
+    if (!s || typeof s !== 'object') return problems.push(`${at} is not an object`);
+    if (typeof s.name !== 'string' || !s.name.trim()) problems.push(`${at} needs a name`);
+    else if (names.has(s.name)) problems.push(`${at}: duplicate name`);
+    else names.add(s.name);
+    if (typeof s.prompt !== 'string' || s.prompt.trim().length < 20) problems.push(`${at}: prompt must be at least 20 characters`);
+    const strings = (v) => Array.isArray(v) && v.every((x) => typeof x === 'string' && x.trim().length >= 10);
+    if (!strings(s.expect) || !s.expect.length) problems.push(`${at}: "expect" must be a non-empty list of criteria (10+ characters each)`);
+    if (s.forbid !== undefined && !strings(s.forbid)) problems.push(`${at}: "forbid" must be a list of criteria (10+ characters each)`);
+    if (s.pressure !== undefined && (!Array.isArray(s.pressure) || s.pressure.some((p) => !PRESSURES.includes(p)))) problems.push(`${at}: "pressure" values must be from ${PRESSURES.join(', ')}`);
+    if (s.files !== undefined && (typeof s.files !== 'object' || Array.isArray(s.files) || Object.entries(s.files).some(([k, v]) => typeof v !== 'string' || path.isAbsolute(k) || k.split(/[\\/]/).includes('..')))) {
+      problems.push(`${at}: "files" maps relative paths to file contents`);
+    }
+  });
+  return problems;
+}
+
+module.exports = { loadBehavior, validate, behaviorFile, PRESSURES, MIN_SCENARIOS };

package/scripts/lib/hooks-install.js

@@ -13,7 +13,7 @@ const path = require('path');
 
 const RUNNER_RE = /\.kete-loom[\\/]hooks[\\/]run\.js"?\s+([a-z]+)\s+([a-z0-9-]+)(?:\s+([a-z-]+))?\s*$/;
 // Seconds. A formatter run after an edit gets longer than a check before one.
-const TIMEOUT_S = { 'pre-shell': 10, 'pre-edit': 10, 'post-edit': 60, 'session-start': 10 };
+const TIMEOUT_S = { 'pre-shell': 10, 'pre-edit': 10, 'post-edit': 60, 'session-start': 10, stop: 10, 'stop-gate': 180 };
 
 const runtimeDir = (home) => path.join(home, '.kete-loom', 'hooks');
 const command = (home, host, hook, event = 'pre-shell', node = process.execPath) =>
@@ -26,13 +26,15 @@ function ours(cmd, hook) {
 
 // Host event name and tool matcher for each kete-loom event; a missing entry means the host can't
 // run that event (Cursor has no documented pre-edit hook; OpenCode can't add context at session start).
+// stop-gate needs a stop hook that can make the agent continue: Kete Code's Stop can only notify, and
+// OpenCode's session.idle can't do either from a command.
 const EVENTS = {
-  claude: { 'pre-shell': ['PreToolUse', 'Bash'], 'pre-edit': ['PreToolUse', 'Edit|Write|NotebookEdit'], 'post-edit': ['PostToolUse', 'Edit|Write|NotebookEdit'], 'session-start': ['SessionStart'] },
-  codex: { 'pre-shell': ['PreToolUse', 'Bash'], 'pre-edit': ['PreToolUse', 'apply_patch'], 'post-edit': ['PostToolUse', 'apply_patch'], 'session-start': ['SessionStart'] },
-  gemini: { 'pre-shell': ['BeforeTool', 'run_shell_command'], 'pre-edit': ['BeforeTool', 'write_file|replace'], 'post-edit': ['AfterTool', 'write_file|replace'], 'session-start': ['SessionStart'] },
-  kete: { 'pre-shell': ['PreToolUse', 'shell'], 'pre-edit': ['PreToolUse', 'edit|write|patch'], 'post-edit': ['PostToolUse', 'edit|write|patch'], 'session-start': ['SessionStart'] },
-  cursor: { 'pre-shell': ['beforeShellExecution'], 'post-edit': ['afterFileEdit'], 'session-start': ['sessionStart'] },
-  copilot: { 'pre-shell': ['preToolUse'], 'pre-edit': ['preToolUse'], 'post-edit': ['postToolUse'], 'session-start': ['sessionStart'] },
+  claude: { 'pre-shell': ['PreToolUse', 'Bash'], 'pre-edit': ['PreToolUse', 'Edit|Write|NotebookEdit'], 'post-edit': ['PostToolUse', 'Edit|Write|NotebookEdit'], 'session-start': ['SessionStart'], stop: ['Stop'], 'stop-gate': ['Stop'] },
+  codex: { 'pre-shell': ['PreToolUse', 'Bash'], 'pre-edit': ['PreToolUse', 'apply_patch'], 'post-edit': ['PostToolUse', 'apply_patch'], 'session-start': ['SessionStart'], stop: ['Stop'], 'stop-gate': ['Stop'] },
+  gemini: { 'pre-shell': ['BeforeTool', 'run_shell_command'], 'pre-edit': ['BeforeTool', 'write_file|replace'], 'post-edit': ['AfterTool', 'write_file|replace'], 'session-start': ['SessionStart'], stop: ['AfterAgent'], 'stop-gate': ['AfterAgent'] },
+  kete: { 'pre-shell': ['PreToolUse', 'shell'], 'pre-edit': ['PreToolUse', 'edit|write|patch'], 'post-edit': ['PostToolUse', 'edit|write|patch'], 'session-start': ['SessionStart'], stop: ['Stop'] },
+  cursor: { 'pre-shell': ['beforeShellExecution'], 'post-edit': ['afterFileEdit'], 'session-start': ['sessionStart'], stop: ['stop'], 'stop-gate': ['stop'] },
+  copilot: { 'pre-shell': ['preToolUse'], 'pre-edit': ['preToolUse'], 'post-edit': ['postToolUse'], 'session-start': ['sessionStart'], stop: ['agentStop'], 'stop-gate': ['agentStop'] },
   opencode: { 'pre-shell': ['tool.execute.before'], 'pre-edit': ['tool.execute.before'], 'post-edit': ['tool.execute.after'] },
 };
 

package/scripts/lib/lint.js

@@ -5,8 +5,10 @@
 // repository-wide checks on top.
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { TOOLS } = require('./render');
+const { loadBehavior } = require('./behavior');
 
 const NAME_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 const SEMVER_RE = /^\d+\.\d+\.\d+$/;
@@ -15,7 +17,7 @@ const CATEGORIES = ['coding', 'testing', 'security', 'integrations', 'devops', '
 const RISKS = ['read-only', 'writes-files', 'runs-commands', 'network'];
 const MAX_LINES = 300;
 const MIN_EVALS = 3;
-const HOOK_EVENTS = ['pre-shell', 'pre-edit', 'post-edit', 'session-start'];
+const HOOK_EVENTS = ['pre-shell', 'pre-edit', 'post-edit', 'session-start', 'stop', 'stop-gate'];
 const MAX_RULE_LINES = 80;
 // Tool names that only exist in one host. Skills should describe the action instead.
 const HOST_SPECIFIC = /\b(Bash tool|Read tool|Edit tool|Write tool|Grep tool|Glob tool|TodoWrite|apply_patch|str_replace_editor)\b/;
@@ -112,6 +114,12 @@ function lintItem(item) {
     }
   }
 
+  // Behaviour evals are optional; when present they must be runnable.
+  if (item.kind === 'skill' || item.kind === 'agent') {
+    const behavior = loadBehavior(item);
+    if (behavior) errors.push(...behavior.problems);
+  }
+
   const hostHit = HOST_SPECIFIC.exec(item.body);
   if (hostHit) warnings.push(`mentions host-specific tool "${hostHit[1]}"; describe the action instead so every host can follow it`);
 
@@ -138,6 +146,21 @@ function lintHook(hook) {
   } catch (e) {
     return [...errors, `cases.json missing or invalid: ${e.message}`];
   }
+  // Hooks that remember what they've seen keep it under KETE_LOOM_STATE_DIR; give each lint run a fresh one.
+  const prevState = process.env.KETE_LOOM_STATE_DIR;
+  const stateDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kete-loom-lint-'));
+  process.env.KETE_LOOM_STATE_DIR = stateDir;
+  try {
+    lintCases(check, cases, errors);
+  } finally {
+    if (prevState === undefined) delete process.env.KETE_LOOM_STATE_DIR;
+    else process.env.KETE_LOOM_STATE_DIR = prevState;
+    fs.rmSync(stateDir, { recursive: true, force: true });
+  }
+  return errors;
+}
+
+function lintCases(check, cases, errors) {
   for (const [key, want] of [['should_block', true], ['should_allow', false]]) {
     if (!Array.isArray(cases[key]) || cases[key].length < MIN_EVALS) errors.push(`cases.json needs at least ${MIN_EVALS} "${key}" cases`);
     for (const c of cases[key] || []) {
@@ -152,7 +175,6 @@ function lintHook(hook) {
       if (got !== want) errors.push(`case ${JSON.stringify(c)} should ${want ? 'block' : 'be allowed'}`);
     }
   }
-  return errors;
 }
 
 module.exports = { lintItem, lintHook, words, jaccard, NAME_RE, SEMVER_RE, CATEGORIES, RISKS, MAX_LINES, HOOK_EVENTS };

package/scripts/lib/mcp-install.js

@@ -10,6 +10,7 @@
 //   Copilot CLI  ~/.copilot/mcp-config.json `mcpServers`; local servers only (its OAuth isn't documented)
 //   OpenCode     opencode.json `mcp` (command is an array)
 //   Kete Code    kete.json `mcp.servers`
+//   Kiro         ~/.kiro/settings/mcp.json `mcpServers` (remote servers sign in with OAuth)
 // An entry is ours when it equals what we would write, so a server you configured yourself under the
 // same name is never touched. Claude Code's CLI-managed servers are tracked in ~/.kete-loom/mcp.json.
 
@@ -33,6 +34,7 @@ const RENDER = {
   copilot: (s) => (http(s) ? null : { type: 'local', command: s.command, args: s.args, tools: ['*'] }),
   opencode: (s) => (http(s) ? { type: 'remote', url: s.url, enabled: true } : { type: 'local', command: [s.command, ...s.args], enabled: true }),
   kete: (s) => (http(s) ? { type: 'remote', url: s.url } : { type: 'local', command: [s.command, ...s.args] }),
+  kiro: (s) => (http(s) ? { url: s.url } : { command: s.command, args: s.args }),
 };
 
 const SIGN_IN = {
@@ -42,6 +44,7 @@ const SIGN_IN = {
   cursor: (n) => `Cursor asks you to sign in to ${n} the first time it connects`,
   opencode: (n) => `opencode mcp auth ${n}`,
   kete: (n) => `kete mcp auth ${n}`,
+  kiro: (n) => `Kiro opens a browser to sign in to ${n} the first time it connects`,
 };
 
 const keteFile = (dir) => (fs.existsSync(path.join(dir, 'kete.jsonc')) ? path.join(dir, 'kete.jsonc') : path.join(dir, 'kete.json'));
@@ -54,8 +57,9 @@ const JSON_HOSTS = {
   copilot: { file: { user: (h) => path.join(process.env.COPILOT_HOME || path.join(h, '.copilot'), 'mcp-config.json') }, holder: (d) => (d.mcpServers ||= {}), standalone: true },
   opencode: { file: { user: (h) => path.join(h, '.config', 'opencode', 'opencode.json'), project: (cwd) => path.join(cwd, 'opencode.json') }, holder: (d) => (d.mcp ||= {}) },
   kete: { file: { user: (h) => keteFile(path.join(h, '.config', 'kete')), project: (cwd) => keteFile(path.join(cwd, '.kete')) }, holder: (d) => ((d.mcp ||= {}).servers ||= {}) },
+  kiro: { file: { user: (h) => path.join(h, '.kiro', 'settings', 'mcp.json'), project: (cwd) => path.join(cwd, '.kiro', 'settings', 'mcp.json') }, holder: (d) => (d.mcpServers ||= {}), standalone: true },
 };
-const MCP_HOSTS = ['claude', 'codex', 'gemini', 'cursor', 'copilot', 'opencode', 'kete'];
+const MCP_HOSTS = ['claude', 'codex', 'gemini', 'cursor', 'copilot', 'opencode', 'kete', 'kiro'];
 
 const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);