klyro 1.0.4 → 1.0.6

package/dist/checkpoints/store.js

@@ -154,6 +154,26 @@ export async function listCheckpoints(cwd) {
         return [];
     }
 }
+/** Numbered snapshot list for `/checkpoints` and the `/rewind` menu. */
+export async function listCheckpointInfo(cwd) {
+    const ids = await listCheckpoints(cwd);
+    const out = [];
+    for (let i = ids.length - 1; i >= 0; i--) {
+        const id = ids[i];
+        let ts = 0;
+        let files = 0;
+        try {
+            const meta = JSON.parse(await fs.readFile(path.join(ckptDir(cwd), id, '.meta.json'), 'utf-8'));
+            if (typeof meta.ts === 'number')
+                ts = meta.ts;
+            if (Array.isArray(meta.files))
+                files = meta.files.length;
+        }
+        catch { /* best-effort */ }
+        out.push({ index: ids.length - i, id, ts, files });
+    }
+    return out;
+}
 export async function diff(cwd, id) {
     const ckpts = await listCheckpoints(cwd);
     const target = id ?? ckpts[ckpts.length - 1];

package/dist/cli/auth.js

@@ -132,13 +132,21 @@ export async function runLogout(provider) {
 }
 export function getStoredKey(provider) {
     try {
-        // Warn (don't refuse) when the credentials file is group/other-readable.
-        // Refusing would lock out existing users with old umasks; warn instead.
+        // Refuse (don't just warn) when the credentials file is
+        // group/other-readable: a key other users can read is compromised by
+        // definition. Repair hint included. KLYRO_CREDENTIALS_INSECURE_OK=1
+        // preserves the old warn-and-continue behavior for exotic setups.
         if (process.platform !== 'win32') {
             try {
                 const st = fsSync.statSync(credPath());
                 if ((st.mode & 0o077) !== 0) {
-                    process.stderr.write(`warning: credentials file ${credPath()} is group/other-readable (mode ${(st.mode & 0o777).toString(8)}) — run chmod 600 on it\n`);
+                    if (process.env.KLYRO_CREDENTIALS_INSECURE_OK === '1') {
+                        process.stderr.write(`warning: credentials file ${credPath()} is group/other-readable (mode ${(st.mode & 0o777).toString(8)}) — run chmod 600 on it\n`);
+                    }
+                    else {
+                        process.stderr.write(`klyro: refusing to use group/other-readable credentials file ${credPath()} (mode ${(st.mode & 0o777).toString(8)}) — run: chmod 600 ${credPath()} (or set KLYRO_CREDENTIALS_INSECURE_OK=1 to override)\n`);
+                        return undefined;
+                    }
                 }
             }
             catch { /* missing file → no warning */ }

package/dist/cli/completion.js

@@ -2,40 +2,93 @@
  * 1.2 — klyro completion
  * Generates shell completion scripts for bash/zsh/fish/powershell.
  */
-const COMMANDS = ['tui', 'run', 'chat', 'config', 'doctor', 'completion', 'update', 'eval', 'session', 'resume', 'help', 'version'];
+const COMMANDS = ['tui', 'run', 'chat', 'config', 'doctor', 'init', 'completion', 'update', 'eval', 'session', 'resume', 'help', 'version', 'scan', 'project', 'mcp', 'hooks', 'agents', 'commit', 'audit', 'benchmark', 'sessions', 'login', 'logout'];
+/** Second-level completion: global flags + per-command flags. */
+const GLOBAL_FLAGS = ['--cwd', '--config', '--debug', '--verbose', '--quiet', '--json', '--yes', '--no-color', '--print', '--output-format', '--no-stream', '--show-thinking', '--tui', '--chat', '--continue', '--resume', '--help', '--version'];
+const COMMAND_FLAGS = {
+    run: ['-m', '--model', '--max-steps', '--max-tokens', '--temperature', '--timeout', '--base-url', '--api-key', '--output', '--provider', '--dry-run', '--resume', '--resume-session', '--verify', '--verify-command', '--verify-mode', '--max-repairs', '--persist', '--require-verify', '--agent', '--max-depth', '--bare'],
+    chat: ['-s', '--system', '-m', '--model', '-t', '--timeout'],
+    eval: ['--output', '--suite', '--filter', '--runs', '--parallel', '--model'],
+    tui: ['-m', '--model', '--max-steps'],
+    doctor: ['--json'],
+    session: ['list', 'show', 'resume', 'fork', 'delete'],
+    sessions: ['export', 'import', 'fork', 'delete'],
+    mcp: ['list', 'add', 'remove', 'probe', 'serve'],
+    config: ['list', 'get', 'set', 'unset', 'path'],
+    commit: ['--dry-run', '--message', '--force-secret'],
+    completion: ['bash', 'zsh', 'fish', 'powershell'],
+    resume: ['-m', '--model', '--max-steps'],
+};
+function flagsFor(cmd) {
+    return [...GLOBAL_FLAGS, ...(COMMAND_FLAGS[cmd] ?? [])];
+}
 function bashScript() {
-    return `# klyro bash completion
+    const cmdCases = Object.entries(COMMAND_FLAGS)
+        .map(([c, fs]) => `      ${c}) opts="${fs.join(' ')}" ;;`)
+        .join('\n');
+    return `# klyro bash completion (commands + flags)
 _klyro_complete() {
   local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
   local cmds="${COMMANDS.join(' ')}"
-  COMPREPLY=( $(compgen -W "$cmds" -- "$cur") )
+  if [[ $COMP_CWORD -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "$cmds ${GLOBAL_FLAGS.join(' ')}" -- "$cur") )
+    return
+  fi
+  local first="\${COMP_WORDS[1]}"
+  local opts=""
+  case "$first" in
+${cmdCases}
+    *) opts="${GLOBAL_FLAGS.join(' ')}" ;;
+  esac
+  COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
 }
 complete -F _klyro_complete klyro
 complete -F _klyro_complete ky
 `;
 }
 function zshScript() {
+    const cmdCases = Object.entries(COMMAND_FLAGS)
+        .map(([c, fs]) => `      ${c}) _values 'flags' ${fs.map((f) => `'${f}'`).join(' ')} ;;`)
+        .join('\n');
     return `#compdef klyro ky
 _klyro() {
-  local -a completions
-  completions=(${COMMANDS.map((c) => `'${c}'`).join(' ')})
-  _describe 'klyro commands' completions
+  if (( CURRENT == 2 )); then
+    _describe 'klyro commands' ${COMMANDS.map((c) => `'${c}'`).join(' ')} ${GLOBAL_FLAGS.map((f) => `'${f}'`).join(' ')}
+    return
+  fi
+  case "$words[2]" in
+${cmdCases}
+    *) _values 'flags' ${GLOBAL_FLAGS.map((f) => `'${f}'`).join(' ')} ;;
+  esac
 }
 compdef _klyro klyro ky
 `;
 }
 function fishScript() {
-    return `# klyro fish completion
-${COMMANDS.map((c) => `complete -c klyro -f -a ${c}`).join('\n')}
+    const flagLines = Object.entries(COMMAND_FLAGS)
+        .flatMap(([c, fs]) => fs.map((f) => `complete -c klyro -f -n "__fish_seen_subcommand_from ${c}" -a ${f}`))
+        .join('\n');
+    return `# klyro fish completion (commands + flags)
+${COMMANDS.map((c) => `complete -c klyro -f -n __fish_use_subcommand -a ${c}`).join('\n')}
+${flagLines}
 complete -c ky -f -a "${COMMANDS.join(' ')}"
 `;
 }
 function powershellScript() {
-    return `# klyro powershell completion
+    return `# klyro powershell completion (commands + flags)
 Register-ArgumentCompleter -Native -CommandName klyro,ky -ScriptBlock {
   param($wordToComplete, $commandAst, $cursorPosition)
   $cmds = @(${COMMANDS.map((c) => `'${c}'`).join(', ')})
-  $cmds | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+  $flags = @(${GLOBAL_FLAGS.map((f) => `'${f}'`).join(', ')})
+  $tokens = $commandAst.ToString() -split '\\s+'
+  if ($tokens.Count -le 2) { $cands = $cmds + $flags } else {
+    switch ($tokens[1]) {
+${Object.entries(COMMAND_FLAGS).map(([c, fs]) => `      '${c}' { $cands = @(${fs.map((f) => `'${f}'`).join(', ')}) }`).join('\n')}
+      default { $cands = $flags }
+    }
+  }
+  $cands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
     [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
   }
 }

package/dist/cli/config.d.ts

@@ -7,8 +7,8 @@ import { z } from 'zod';
 export declare const ConfigSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
     provider: z.ZodOptional<z.ZodEnum<{
-        openai: "openai";
         anthropic: "anthropic";
+        openai: "openai";
     }>>;
     baseUrl: z.ZodOptional<z.ZodString>;
     apiKey: z.ZodOptional<z.ZodString>;
@@ -20,8 +20,8 @@ export declare const ConfigSchema: z.ZodObject<{
     providers: z.ZodOptional<z.ZodObject<{
         failover: z.ZodOptional<z.ZodArray<z.ZodObject<{
             provider: z.ZodEnum<{
-                openai: "openai";
                 anthropic: "anthropic";
+                openai: "openai";
             }>;
             baseURL: z.ZodOptional<z.ZodString>;
             apiKey: z.ZodOptional<z.ZodString>;
@@ -32,8 +32,8 @@ export declare const ConfigSchema: z.ZodObject<{
 export type KlyroConfig = z.infer<typeof ConfigSchema>;
 export declare const FailoverEntrySchema: z.ZodObject<{
     provider: z.ZodEnum<{
-        openai: "openai";
         anthropic: "anthropic";
+        openai: "openai";
     }>;
     baseURL: z.ZodOptional<z.ZodString>;
     apiKey: z.ZodOptional<z.ZodString>;
@@ -43,8 +43,8 @@ export type FailoverEntry = z.infer<typeof FailoverEntrySchema>;
 export declare const FailoverConfigSchema: z.ZodObject<{
     failover: z.ZodOptional<z.ZodArray<z.ZodObject<{
         provider: z.ZodEnum<{
-            openai: "openai";
             anthropic: "anthropic";
+            openai: "openai";
         }>;
         baseURL: z.ZodOptional<z.ZodString>;
         apiKey: z.ZodOptional<z.ZodString>;

package/dist/cli/doctor.js

@@ -108,6 +108,18 @@ function checkPlatform() {
     const ok = ['win32', 'linux', 'darwin'].includes(process.platform);
     return { name: 'Platform', ok, detail: `${process.platform} ${process.arch} ${ok ? '✓' : '✗ unsupported'}` };
 }
+async function checkSandbox() {
+    try {
+        const { detectSandbox } = await import('../tools/shell/sandbox.js');
+        const st = detectSandbox();
+        if (st.active)
+            return { name: 'Sandbox', ok: true, detail: `${st.backend} ✓` };
+        return { name: 'Sandbox', ok: true, detail: `none — ${st.reason ?? 'policy+path guards only'}` };
+    }
+    catch {
+        return { name: 'Sandbox', ok: true, detail: 'none — policy+path guards only' };
+    }
+}
 async function checkMcp(cwd) {
     try {
         const { loadMcpServers } = await import('../mcp/config.js');
@@ -167,6 +179,7 @@ export async function runDoctor(opts = {}) {
     checks.push(await checkGit());
     checks.push(await checkTools());
     checks.push(checkPlatform());
+    checks.push(await checkSandbox());
     const mcpCheck = await checkMcp(cwd);
     const trustCheck = await checkTrust();
     checks.push(mcpCheck);

package/dist/cli/eval.d.ts

@@ -54,6 +54,10 @@ export interface EvalScenario {
     };
     /** Adapter events to script, as [eventKind, ...args] tuples. */
     scripted_events?: Array<Array<unknown[]>>;
+    /** Semantic rubric graded by a model judge (needs --judge-model). */
+    judge?: {
+        rubric: string[];
+    };
     expect?: {
         status?: RunResult['status'];
         textContains?: string;
@@ -70,6 +74,11 @@ export interface EvalResult {
     toolCalls: number;
     text: string;
     durationMs: number;
+    judge?: {
+        pass: boolean;
+        notes: string;
+        skipped: boolean;
+    };
 }
 export interface RunEvalOptions {
     inputPath: string;
@@ -79,7 +88,12 @@ export interface RunEvalOptions {
     runs?: number;
     parallel?: number;
     model?: string;
+    /** Live model id for grading `judge.rubric` (env endpoint + key required). */
+    judgeModel?: string;
 }
 export declare function runEval(opts: RunEvalOptions): Promise<number>;
 export declare function scriptedAdapterFromSpec(spec: Array<Array<unknown[]>> | undefined): ProviderAdapter;
-export declare function runScenario(sc: EvalScenario): Promise<EvalResult>;
+export declare function runScenario(sc: EvalScenario, judgeOpts?: {
+    adapter: ProviderAdapter;
+    model: string;
+}): Promise<EvalResult>;

package/dist/cli/eval.js

@@ -131,10 +131,23 @@ export async function runEval(opts) {
         stderr.write('klyro eval: no scenarios in input\n');
         return 2;
     }
+    // Live judge adapter for `judge.rubric` (env endpoint + key; mock otherwise).
+    let judgeAdapter;
+    if (opts.judgeModel) {
+        const { httpChatAdapter } = await import('../agent/provider-adapter.js');
+        const { getStoredKey } = await import('./auth.js');
+        const baseUrl = process.env.KLYRO_BASE_URL;
+        const apiKey = process.env.KLYRO_API_KEY ?? getStoredKey('openai') ?? getStoredKey('anthropic');
+        if (!baseUrl || !apiKey) {
+            stderr.write('klyro eval: --judge-model needs KLYRO_BASE_URL and KLYRO_API_KEY (or a stored key)\n');
+            return 2;
+        }
+        judgeAdapter = httpChatAdapter({ baseURL: baseUrl, apiKey });
+    }
     const results = [];
     for (const sc of scenarios) {
         const start = Date.now();
-        const r = await runScenario(sc);
+        const r = await runScenario(sc, judgeAdapter && opts.judgeModel ? { adapter: judgeAdapter, model: opts.judgeModel } : undefined);
         r.durationMs = Date.now() - start;
         results.push(r);
         if (opts.output === 'json') {
@@ -223,7 +236,7 @@ function tupleToEvent(tuple) {
             throw new Error(`scriptedAdapterFromSpec: unknown event kind: ${kind}`);
     }
 }
-export async function runScenario(sc) {
+export async function runScenario(sc, judgeOpts) {
     const failures = [];
     const model = sc.model ?? 'mock';
     const adapter = scriptedAdapterFromSpec(sc.scripted_events);
@@ -265,6 +278,24 @@ export async function runScenario(sc) {
     if (exp.toolCallsAtMost !== undefined && result.toolCalls > exp.toolCallsAtMost) {
         failures.push(`toolCalls: expected <= ${exp.toolCallsAtMost}, got ${result.toolCalls}`);
     }
+    // Model-graded semantic check (opt-in: needs a live judge adapter).
+    let judge;
+    if (sc.judge && sc.judge.rubric.length > 0) {
+        if (judgeOpts) {
+            const { runJudge } = await import('../eval/judge.js');
+            const v = await runJudge(judgeOpts.adapter, judgeOpts.model, {
+                task: sc.task,
+                finalText: result.finalText,
+                toolCalls: result.toolCalls,
+            }, sc.judge.rubric);
+            judge = { pass: v.pass, notes: v.notes, skipped: v.skipped };
+            if (!v.pass)
+                failures.push(`judge: ${v.notes || 'rubric unmet'}`);
+        }
+        else {
+            judge = { pass: true, notes: 'no judge adapter — skipped', skipped: true };
+        }
+    }
     return {
         name: sc.name,
         passed: failures.length === 0,
@@ -274,5 +305,6 @@ export async function runScenario(sc) {
         toolCalls: result.toolCalls,
         text: result.finalText,
         durationMs: 0,
+        ...(judge ? { judge } : {}),
     };
 }

package/dist/cli/hooks.d.ts

@@ -1,26 +1,46 @@
 /**
- * Hooks engine (10.2) — preToolUse / postToolUse shell hooks.
+ * Hooks engine (10.2, v2) — lifecycle + tool shell hooks.
+ *
+ * Events: `preToolUse` / `postToolUse` (per tool call), `sessionStart`
+ * (once per run, may abort it), `sessionEnd` (once per run, best-effort),
+ * `stop` (after each agent step).
  *
  * Config files:
  *   - project: `<cwd>/.klyro/hooks.json`
  *   - global:  `~/.klyro/hooks.json` (merged; project wins on name clash)
  *
- * Schema: `{ hooks: Array<{ name, event, command, timeoutMs? }> }`.
+ * Schema: `{ hooks: Array<{ name, event, command, matcher?, timeoutMs? }> }`.
+ * `matcher` is a regex tested against the tool name — lifecycle events
+ * (`sessionStart`/`sessionEnd`/`stop`) always match; tool events without a
+ * matcher match every tool.
  *
  * `loadHooks` never throws — a missing file is `[]`, an invalid file is
  * `[]` plus a one-time stderr warning per path. `runHook` spawns the
  * command with `shell: true` (commands are strings, must work on win +
- * posix), a default 30s timeout, a filtered env, plus `KLYRO_TOOL_NAME`
- * and `KLYRO_TOOL_INPUT_JSON` for the hook's inspection.
+ * posix), a default 30s timeout, a filtered env, `KLYRO_TOOL_NAME` /
+ * `KLYRO_TOOL_INPUT_JSON` for inspection, AND the full JSON payload on
+ * stdin (`{ event, tool, input, sessionId, ... }`).
  */
 import { z } from 'zod';
+export declare const HookEventSchema: z.ZodEnum<{
+    stop: "stop";
+    preToolUse: "preToolUse";
+    postToolUse: "postToolUse";
+    sessionStart: "sessionStart";
+    sessionEnd: "sessionEnd";
+}>;
+export type HookEvent = z.infer<typeof HookEventSchema>;
 export declare const HookSchema: z.ZodObject<{
     name: z.ZodString;
     event: z.ZodEnum<{
+        stop: "stop";
         preToolUse: "preToolUse";
         postToolUse: "postToolUse";
+        sessionStart: "sessionStart";
+        sessionEnd: "sessionEnd";
     }>;
     command: z.ZodString;
+    matcher: z.ZodOptional<z.ZodString>;
     timeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type Hook = z.infer<typeof HookSchema>;
@@ -40,8 +60,37 @@ export interface HookContext {
     toolName: string;
     input: unknown;
 }
+/** Lifecycle payload delivered on stdin (and merged into env where small). */
+export interface HookPayload {
+    event: HookEvent;
+    tool?: string;
+    input?: unknown;
+    sessionId?: string;
+    cwd?: string;
+    status?: string;
+    step?: number;
+}
+/**
+ * Select hooks for an event. Tool events honor `matcher` (regex against the
+ * tool name; invalid regex never matches); lifecycle events always match.
+ * Exported pure for unit tests.
+ */
+export declare function hooksForEvent(hooks: Hook[], event: HookEvent, toolName?: string): Hook[];
 /**
  * Run one hook. Resolves (never rejects) with the exit code + sliced
  * output. `ok` is true only when the process exited 0.
+ *
+ * `stdinJson` (when given) is written to the child's stdin as JSON —
+ * the primary contract (mirrors CC's stdin-JSON hooks); the env vars are
+ * kept as a convenience for shell one-liners.
+ */
+export declare function runHook(hook: Hook, ctx: HookContext, stdinJson?: unknown): Promise<HookResult>;
+/**
+ * Run all `sessionEnd` hooks for a finished run (best-effort, sequential).
+ * Returns hook outputs for logging. Never throws.
  */
-export declare function runHook(hook: Hook, ctx: HookContext): Promise<HookResult>;
+export declare function runSessionEndHooks(cwd: string, sessionId: string | undefined, status: string): Promise<Array<{
+    name: string;
+    ok: boolean;
+    output: string;
+}>>;

package/dist/cli/hooks.js

@@ -1,27 +1,38 @@
 /**
- * Hooks engine (10.2) — preToolUse / postToolUse shell hooks.
+ * Hooks engine (10.2, v2) — lifecycle + tool shell hooks.
+ *
+ * Events: `preToolUse` / `postToolUse` (per tool call), `sessionStart`
+ * (once per run, may abort it), `sessionEnd` (once per run, best-effort),
+ * `stop` (after each agent step).
  *
  * Config files:
  *   - project: `<cwd>/.klyro/hooks.json`
  *   - global:  `~/.klyro/hooks.json` (merged; project wins on name clash)
  *
- * Schema: `{ hooks: Array<{ name, event, command, timeoutMs? }> }`.
+ * Schema: `{ hooks: Array<{ name, event, command, matcher?, timeoutMs? }> }`.
+ * `matcher` is a regex tested against the tool name — lifecycle events
+ * (`sessionStart`/`sessionEnd`/`stop`) always match; tool events without a
+ * matcher match every tool.
  *
  * `loadHooks` never throws — a missing file is `[]`, an invalid file is
  * `[]` plus a one-time stderr warning per path. `runHook` spawns the
  * command with `shell: true` (commands are strings, must work on win +
- * posix), a default 30s timeout, a filtered env, plus `KLYRO_TOOL_NAME`
- * and `KLYRO_TOOL_INPUT_JSON` for the hook's inspection.
+ * posix), a default 30s timeout, a filtered env, `KLYRO_TOOL_NAME` /
+ * `KLYRO_TOOL_INPUT_JSON` for inspection, AND the full JSON payload on
+ * stdin (`{ event, tool, input, sessionId, ... }`).
  */
 import { spawn } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { z } from 'zod';
+export const HookEventSchema = z.enum(['preToolUse', 'postToolUse', 'sessionStart', 'sessionEnd', 'stop']);
 export const HookSchema = z.object({
     name: z.string().min(1),
-    event: z.enum(['preToolUse', 'postToolUse']),
+    event: HookEventSchema,
     command: z.string().min(1),
+    /** Optional regex matched against the tool name (tool events only). */
+    matcher: z.string().min(1).optional(),
     timeoutMs: z.number().int().positive().optional(),
 });
 const HooksFileSchema = z.object({
@@ -116,11 +127,36 @@ function hookEnv() {
     out.PATH = process.env.PATH;
     return out;
 }
+/**
+ * Select hooks for an event. Tool events honor `matcher` (regex against the
+ * tool name; invalid regex never matches); lifecycle events always match.
+ * Exported pure for unit tests.
+ */
+export function hooksForEvent(hooks, event, toolName) {
+    return hooks.filter((h) => {
+        if (h.event !== event)
+            return false;
+        if (h.matcher === undefined)
+            return true;
+        if (toolName === undefined)
+            return true; // lifecycle events have no tool
+        try {
+            return new RegExp(h.matcher).test(toolName);
+        }
+        catch {
+            return false;
+        }
+    });
+}
 /**
  * Run one hook. Resolves (never rejects) with the exit code + sliced
  * output. `ok` is true only when the process exited 0.
+ *
+ * `stdinJson` (when given) is written to the child's stdin as JSON —
+ * the primary contract (mirrors CC's stdin-JSON hooks); the env vars are
+ * kept as a convenience for shell one-liners.
  */
-export function runHook(hook, ctx) {
+export function runHook(hook, ctx, stdinJson) {
     const timeoutMs = hook.timeoutMs ?? DEFAULT_HOOK_TIMEOUT_MS;
     return new Promise((resolve) => {
         let env;
@@ -139,6 +175,13 @@ export function runHook(hook, ctx) {
         catch {
             env.KLYRO_TOOL_INPUT_JSON = '{}';
         }
+        let payload = '';
+        try {
+            payload = JSON.stringify(stdinJson ?? { event: 'preToolUse', tool: ctx.toolName, input: ctx.input ?? {} });
+        }
+        catch {
+            payload = '{}';
+        }
         let child;
         try {
             child = spawn(hook.command, {
@@ -147,6 +190,7 @@ export function runHook(hook, ctx) {
                 windowsHide: true,
                 timeout: timeoutMs,
                 env,
+                stdio: ['pipe', 'pipe', 'pipe'],
             });
         }
         catch (err) {
@@ -177,5 +221,40 @@ export function runHook(hook, ctx) {
                 stderr: stderr.slice(0, MAX_HOOK_OUTPUT_CHARS),
             });
         });
+        // Deliver the stdin JSON contract, then close so the child never hangs
+        // waiting for EOF. Write errors (EPIPE on early exit) are ignored —
+        // the exit code below is what matters.
+        try {
+            if (child.stdin) {
+                child.stdin.on('error', () => undefined);
+                child.stdin.write(payload);
+                child.stdin.end();
+            }
+        }
+        catch { /* ignore */ }
     });
 }
+/**
+ * Run all `sessionEnd` hooks for a finished run (best-effort, sequential).
+ * Returns hook outputs for logging. Never throws.
+ */
+export async function runSessionEndHooks(cwd, sessionId, status) {
+    const out = [];
+    let hooks;
+    try {
+        hooks = hooksForEvent(loadHooks(cwd), 'sessionEnd');
+    }
+    catch {
+        return out;
+    }
+    for (const h of hooks) {
+        try {
+            const r = await runHook(h, { toolName: '', input: {} }, { event: 'sessionEnd', sessionId, cwd, status });
+            out.push({ name: h.name, ok: r.ok, output: (r.stdout || r.stderr || '').slice(0, 2000) });
+        }
+        catch {
+            out.push({ name: h.name, ok: false, output: '' });
+        }
+    }
+    return out;
+}

package/dist/cli/init.d.ts

@@ -0,0 +1,6 @@
+export interface InitResult {
+    created: string[];
+    skipped: string[];
+}
+export declare function initProject(cwd: string): Promise<InitResult>;
+export declare function nextStepsText(): string;

package/dist/cli/init.js

@@ -0,0 +1,60 @@
+/**
+ * Project bootstrap shared by `klyro init` and the REPL `/init`:
+ * scan-seeded KLYRO.md (only when absent) + `.mcp.json` skeleton.
+ * Never overwrites user files; returns created vs skipped lists.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function captureStdout() {
+    const orig = process.stdout.write.bind(process.stdout);
+    let out = '';
+    process.stdout.write = ((c) => {
+        out += String(c);
+        return true;
+    });
+    return {
+        release: () => {
+            process.stdout.write = orig;
+            return out;
+        },
+    };
+}
+export async function initProject(cwd) {
+    const created = [];
+    const skipped = [];
+    const klyroMd = path.join(cwd, 'KLYRO.md');
+    if (fs.existsSync(klyroMd)) {
+        skipped.push('KLYRO.md (exists)');
+    }
+    else {
+        const { runScan } = await import('./scan.js');
+        const cap = captureStdout();
+        try {
+            await runScan({ cwd, json: false });
+        }
+        finally {
+            // release even if scan throws — partial output still seeds the draft
+        }
+        const out = cap.release();
+        fs.writeFileSync(klyroMd, `# KLYRO.md\n\nProject: ${cwd}\n\n## Stack\n\n${out.slice(0, 2000)}\n\n## Conventions\n\n- Prefer smallest change that solves the task.\n- Run verification after edits.\n`, 'utf-8');
+        created.push('KLYRO.md');
+    }
+    const mcpJson = path.join(cwd, '.mcp.json');
+    if (fs.existsSync(mcpJson)) {
+        skipped.push('.mcp.json (exists)');
+    }
+    else {
+        fs.writeFileSync(mcpJson, JSON.stringify({ mcpServers: {} }, null, 2) + '\n', 'utf-8');
+        created.push('.mcp.json');
+    }
+    return { created, skipped };
+}
+export function nextStepsText() {
+    return [
+        'Next steps:',
+        '  klyro login            # store provider key once (or set KLYRO_BASE_URL/_API_KEY/_MODEL)',
+        '  klyro doctor           # verify toolchain, provider, sessions, sandbox',
+        '  klyro agents           # list subagents (add yours in .klyro/agents/*.md)',
+        '  klyro mcp add <n> <cmd># attach a tool server (or https:// URL for remote)',
+    ].join('\n');
+}