klyro 1.0.5 → 1.0.7

package/dist/cli/auth.d.ts

@@ -1,10 +1,17 @@
 /**
  * 2.2 — klyro login / logout / aliases
- * Stores masked key → ~/.klyro/credentials.json 0600
+ * Stores masked key → OS keychain when available, else
+ * ~/.klyro/credentials.json 0600 (with refuse-on-lax-perms reads).
  */
 export declare function credPath(): string;
-/** Persist one provider key (0600). Never logs or returns the key. */
-export declare function saveKey(provider: string, key: string): Promise<void>;
+/** Persist one provider key: OS keychain when available, else 0600 file. Never logs or returns the key. */
+export declare function saveKey(provider: string, key: string): Promise<'keychain' | 'file'>;
+/**
+ * Async key read: OS keychain first (when available), then the 0600 file
+ * (with refuse-on-lax-perms). Use in async paths (provider resolution,
+ * eval, setup); sync contexts keep `getStoredKey` (file only).
+ */
+export declare function getStoredKeyAsync(provider: string): Promise<string | undefined>;
 /** Which providers have stored keys (names only — never values). */
 export declare function storedProviders(): string[];
 export declare const LOGIN_DEFAULTS: Record<string, {

package/dist/cli/auth.js

@@ -1,6 +1,7 @@
 /**
  * 2.2 — klyro login / logout / aliases
- * Stores masked key → ~/.klyro/credentials.json 0600
+ * Stores masked key → OS keychain when available, else
+ * ~/.klyro/credentials.json 0600 (with refuse-on-lax-perms reads).
  */
 import * as fs from 'node:fs/promises';
 import * as fsSync from 'node:fs';
@@ -15,21 +16,44 @@ export function credPath() {
     const home = os.homedir() || process.cwd();
     return path.join(home, '.klyro', 'credentials.json');
 }
-/** Persist one provider key (0600). Never logs or returns the key. */
+/** Persist one provider key: OS keychain when available, else 0600 file. Never logs or returns the key. */
 export async function saveKey(provider, key) {
+    const trimmed = key.trim();
+    try {
+        const { keychainSet } = await import('./keychain.js');
+        if (await keychainSet(provider, trimmed))
+            return 'keychain';
+    }
+    catch { /* fall through to file */ }
     const creds = {};
     try {
         const raw = await fs.readFile(credPath(), 'utf-8');
         Object.assign(creds, JSON.parse(raw));
     }
     catch { /* ignore */ }
-    creds[provider] = key.trim();
+    creds[provider] = trimmed;
     await fs.mkdir(path.dirname(credPath()), { recursive: true });
     await fs.writeFile(credPath(), JSON.stringify(creds, null, 2), { mode: 0o600 });
     try {
         await fs.chmod(credPath(), 0o600);
     }
     catch { /* ignore on Windows */ }
+    return 'file';
+}
+/**
+ * Async key read: OS keychain first (when available), then the 0600 file
+ * (with refuse-on-lax-perms). Use in async paths (provider resolution,
+ * eval, setup); sync contexts keep `getStoredKey` (file only).
+ */
+export async function getStoredKeyAsync(provider) {
+    try {
+        const { keychainGet } = await import('./keychain.js');
+        const v = await keychainGet(provider);
+        if (v)
+            return v;
+    }
+    catch { /* fall through to file */ }
+    return getStoredKey(provider);
 }
 /** Which providers have stored keys (names only — never values). */
 export function storedProviders() {
@@ -78,8 +102,10 @@ export async function runLogin() {
             const model = ((await rl.question(`Model [${defs.model}]: `)) || defs.model).trim();
             const storeProvider = provider === 'local' ? 'openai' : provider;
             if (key.trim()) {
-                await saveKey(storeProvider, key);
-                process.stdout.write(`Saved ${storeProvider} key to ${credPath()} (0600)\n`);
+                const where = await saveKey(storeProvider, key);
+                process.stdout.write(where === 'keychain'
+                    ? `Saved ${storeProvider} key to the OS keychain\n`
+                    : `Saved ${storeProvider} key to ${credPath()} (0600)\n`);
             }
             // Persist non-secret settings (merged with existing config, never clobbers).
             const { loadConfig, saveConfig } = await import('./config.js');
@@ -106,6 +132,18 @@ export async function runLogin() {
     }
 }
 export async function runLogout(provider) {
+    // Best-effort keychain removal first (a keychain-held key must not survive
+    // a file-only logout).
+    try {
+        const { keychainDelete } = await import('./keychain.js');
+        if (provider)
+            await keychainDelete(provider);
+        else {
+            await keychainDelete('openai');
+            await keychainDelete('anthropic');
+        }
+    }
+    catch { /* ignore */ }
     try {
         const raw = await fs.readFile(credPath(), 'utf-8');
         const creds = JSON.parse(raw);

package/dist/cli/completion.js

@@ -2,11 +2,11 @@
  * 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', 'scan', 'project', 'mcp', 'hooks', 'agents', 'commit', 'audit', 'benchmark', 'sessions', 'login', 'logout'];
+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'],
+    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'],

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

@@ -198,7 +198,6 @@ export async function runDoctor(opts = {}) {
     process.stdout.write('─'.repeat(40) + '\n');
     for (const c of checks) {
         const glyph = c.ok ? '✓' : '✗';
-        const color = c.ok ? '' : '';
         process.stdout.write(`${glyph} ${c.name.padEnd(14)} ${c.detail}\n`);
     }
     process.stdout.write('─'.repeat(40) + '\n');

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

@@ -47,6 +47,19 @@ import { builtinRegistry } from '../tools/registry.js';
 import { builtinRules, DEFAULT_POLICY_CONFIG, PolicyEngine } from '../policy/engine.js';
 import { DenyAllApprovalPrompt } from '../policy/approval.js';
 export async function runEval(opts) {
+    // Live judge adapter (shared by suite + JSONL paths) for `judge.rubric`.
+    let judgeAdapter;
+    if (opts.judgeModel) {
+        const { httpChatAdapter } = await import('../agent/provider-adapter.js');
+        const { getStoredKeyAsync } = await import('./auth.js');
+        const baseUrl = process.env.KLYRO_BASE_URL;
+        const apiKey = process.env.KLYRO_API_KEY ?? (await getStoredKeyAsync('openai')) ?? (await getStoredKeyAsync('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 });
+    }
     // 5.4 — suite mode: load from evals/fixtures
     if (opts.suite) {
         const { runHarness, loadFileFixture } = await import('../eval/harness.js');
@@ -98,12 +111,17 @@ export async function runEval(opts) {
             stderr.write(`klyro eval: no fixtures for suite ${opts.suite}\n`);
             return 2;
         }
-        // Simple harness for suite: just run check.sh via file fixtures
-        const { runFileFixture, loadFileFixture: loadFF } = await import('../eval/harness.js');
+        // Suite runner: agent-driven fixtures (script.json) execute the real
+        // runtime + tools before check.sh; static fixtures just run check.sh.
+        // --judge-model threads a live grader into both paths that declare rubrics.
+        const { runFileFixture, runAgentFixture, loadFileFixture: loadFF } = await import('../eval/harness.js');
         const results = [];
         for (const t of tasks) {
             const fixture = await loadFF(path.join(fixturesDir, t.id));
-            const r = await runFileFixture(fixture, { runs: opts.runs, parallel: opts.parallel });
+            const judgeOpts = judgeAdapter && opts.judgeModel ? { judgeAdapter, judgeModel: opts.judgeModel } : {};
+            const r = fixture.script
+                ? await runAgentFixture(fixture, judgeOpts)
+                : await runFileFixture(fixture, { runs: opts.runs, parallel: opts.parallel });
             results.push(r);
             const tag = r.status === 'pass' ? 'PASS' : 'FAIL';
             if (opts.output === 'json')
@@ -131,10 +149,11 @@ export async function runEval(opts) {
         stderr.write('klyro eval: no scenarios in input\n');
         return 2;
     }
+    // Live judge adapter was built at the top (shared with suite mode).
     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 +242,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 +284,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 +311,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,52 @@
 /**
- * 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; invalid regex never matches.
+ *
+ * Verdict contract: stdout parsed as JSON yields `{decision, message,
+ * context, continue|cont}`. preToolUse `decision:"deny"` blocks with
+ * `message` (wins over exit code); `decision:"allow"` + `context` attaches
+ * model-visible context to the tool result. stop `continue:true` grants one
+ * more turn (max 3/run). Non-JSON stdout keeps pure exit-code semantics.
  *
  * `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>;
@@ -29,6 +55,20 @@ export interface HookResult {
     exitCode: number | null;
     stdout: string;
     stderr: string;
+    /**
+     * Structured verdict parsed from stdout when it is a JSON object
+     * (mirrors CC hook JSON output). Fields:
+     *   - decision: 'allow' | 'deny' (preToolUse; deny wins over exit code)
+     *   - message: denial reason / continuation note
+     *   - context: extra model-visible context (preToolUse allow only)
+     *   - cont: stop-hook request to continue the loop one more turn
+     */
+    verdict?: {
+        decision?: string;
+        message?: string;
+        context?: string;
+        cont?: boolean;
+    };
 }
 export declare const DEFAULT_HOOK_TIMEOUT_MS = 30000;
 /**
@@ -40,8 +80,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,44 @@
 /**
- * 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; invalid regex never matches.
+ *
+ * Verdict contract: stdout parsed as JSON yields `{decision, message,
+ * context, continue|cont}`. preToolUse `decision:"deny"` blocks with
+ * `message` (wins over exit code); `decision:"allow"` + `context` attaches
+ * model-visible context to the tool result. stop `continue:true` grants one
+ * more turn (max 3/run). Non-JSON stdout keeps pure exit-code semantics.
  *
  * `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 +133,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 +181,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 +196,7 @@ export function runHook(hook, ctx) {
                 windowsHide: true,
                 timeout: timeoutMs,
                 env,
+                stdio: ['pipe', 'pipe', 'pipe'],
             });
         }
         catch (err) {
@@ -170,12 +220,73 @@ export function runHook(hook, ctx) {
         });
         child.on('close', (code) => {
             const exitCode = typeof code === 'number' ? code : -1;
+            const out = stdout.slice(0, MAX_HOOK_OUTPUT_CHARS);
             resolve({
                 ok: exitCode === 0,
                 exitCode,
-                stdout: stdout.slice(0, MAX_HOOK_OUTPUT_CHARS),
+                stdout: out,
                 stderr: stderr.slice(0, MAX_HOOK_OUTPUT_CHARS),
+                ...parseVerdict(out),
             });
         });
+        // 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 */ }
     });
 }
+/** Parse a structured JSON verdict from hook stdout (best-effort). */
+function parseVerdict(out) {
+    const trimmed = out.trim();
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}'))
+        return {};
+    try {
+        const p = JSON.parse(trimmed);
+        const verdict = {};
+        if (typeof p['decision'] === 'string')
+            verdict.decision = p['decision'];
+        if (typeof p['message'] === 'string')
+            verdict.message = p['message'].slice(0, 2000);
+        if (typeof p['context'] === 'string')
+            verdict.context = p['context'].slice(0, 2000);
+        if (typeof p['continue'] === 'boolean')
+            verdict.cont = p['continue'];
+        if (typeof p['cont'] === 'boolean' && verdict.cont === undefined)
+            verdict.cont = p['cont'];
+        return Object.keys(verdict).length > 0 ? { verdict } : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * 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;