open-multi-agent-kit 0.78.0 → 0.78.2

package/dist/util/clipboard-image.js

@@ -0,0 +1,263 @@
+/**
+ * Cross-platform clipboard image reader.
+ *
+ * Wraps the platform-specific clipboard reading from screenshot-store patterns
+ * into a reusable utility for the chat REPL, goal commands, and any input
+ * surface that needs Ctrl+V / paste image support.
+ *
+ * Platforms:
+ * - macOS: `pngpaste -` (brew) or `osascript` with TIFF→PNG conversion
+ * - Linux: `xclip -selection clipboard -target image/png`
+ * - Windows: PowerShell System.Windows.Forms.Clipboard
+ *
+ * Output: PNG Buffer + saved file path under .omk/screenshots/
+ */
+import { execFileSync } from "node:child_process";
+import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join, relative } from "node:path";
+export const SCREENSHOT_DIR = ".omk/screenshots";
+export const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+const CLIPBOARD_TIMEOUT_MS = 5000;
+const CLIPBOARD_MAX_BUFFER = MAX_IMAGE_BYTES * 2;
+const IMAGE_MAGIC = [
+    ["png", [0x89, 0x50, 0x4e, 0x47]],
+    ["jpg", [0xff, 0xd8, 0xff]],
+    ["webp", [0x52, 0x49, 0x46, 0x46]],
+    ["gif", [0x47, 0x49, 0x46, 0x38]],
+];
+export function detectImageExt(buf) {
+    for (const [ext, magic] of IMAGE_MAGIC) {
+        if (buf.length >= magic.length && magic.every((b, i) => buf[i] === b)) {
+            return ext;
+        }
+    }
+    return null;
+}
+function mimeTypeForExt(ext) {
+    switch (ext) {
+        case "png": return "image/png";
+        case "jpg": return "image/jpeg";
+        case "webp": return "image/webp";
+        case "gif": return "image/gif";
+        default: return "application/octet-stream";
+    }
+}
+export function toDataUri(base64, ext) {
+    return `data:${mimeTypeForExt(ext)};base64,${base64}`;
+}
+function generatePath(projectRoot, ext) {
+    const dateDir = new Date().toISOString().slice(0, 10);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "").slice(0, 15);
+    const hash = createHash("sha256").update(`${Date.now()}-${Math.random()}`).digest("hex").slice(0, 8);
+    const fileName = `screenshot-${timestamp}-${hash}.${ext}`;
+    const dir = join(projectRoot, SCREENSHOT_DIR, dateDir);
+    mkdirSync(dir, { recursive: true });
+    const fullPath = join(dir, fileName);
+    const relativePath = relative(projectRoot, fullPath).replace(/\\/g, "/");
+    return { fullPath, relativePath };
+}
+// ── Platform readers ────────────────────────────────────────────────────────
+function readMacClipboard() {
+    // Try pngpaste first (faster, more reliable)
+    try {
+        const out = execFileSync("pngpaste", ["-"], {
+            timeout: CLIPBOARD_TIMEOUT_MS,
+            maxBuffer: CLIPBOARD_MAX_BUFFER,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (out.length > 0)
+            return out;
+    }
+    catch {
+        // pngpaste not installed or clipboard empty
+    }
+    // Fallback: osascript (handles TIFF → PNG conversion)
+    try {
+        const script = `
+      set theFile to (POSIX path of (path to temporary items) & "omk-clip-" & (random number from 100000 to 999999) & ".png")
+      set img to the clipboard as «class PNGf»
+      set fRef to open for access POSIX file theFile with write permission
+      write img to fRef
+      close access fRef
+      return theFile
+    `;
+        const filePath = execFileSync("osascript", ["-e", script], {
+            timeout: CLIPBOARD_TIMEOUT_MS,
+            encoding: "utf-8",
+        }).trim();
+        if (filePath) {
+            const buf = readFileSync(filePath);
+            try {
+                unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            if (buf.length > 0)
+                return buf;
+        }
+    }
+    catch {
+        // osascript failed
+    }
+    return null;
+}
+function readLinuxClipboard() {
+    try {
+        const out = execFileSync("xclip", ["-selection", "clipboard", "-target", "image/png", "-o"], {
+            timeout: CLIPBOARD_TIMEOUT_MS,
+            maxBuffer: CLIPBOARD_MAX_BUFFER,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (out.length > 0)
+            return out;
+    }
+    catch {
+        // xclip not available
+    }
+    // Fallback: wl-paste (Wayland)
+    try {
+        const out = execFileSync("wl-paste", ["--type", "image/png"], {
+            timeout: CLIPBOARD_TIMEOUT_MS,
+            maxBuffer: CLIPBOARD_MAX_BUFFER,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (out.length > 0)
+            return out;
+    }
+    catch {
+        // wl-paste not available
+    }
+    return null;
+}
+function readWindowsClipboard() {
+    const script = `
+$ErrorActionPreference = 'SilentlyContinue'
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+function Emit-Bytes([byte[]]$Bytes) {
+  if ($null -eq $Bytes -or $Bytes.Length -eq 0) { exit 1 }
+  [Console]::OpenStandardOutput().Write($Bytes, 0, $Bytes.Length)
+  exit 0
+}
+
+# Try PNG format first
+$data = [System.Windows.Forms.Clipboard]::GetDataObject()
+if ($null -ne $data) {
+  foreach ($format in @('PNG', 'image/png')) {
+    if ($data.GetDataPresent($format)) {
+      $raw = $data.GetData($format)
+      if ($raw -is [System.IO.MemoryStream]) { Emit-Bytes $raw.ToArray() }
+      if ($raw -is [byte[]]) { Emit-Bytes $raw }
+    }
+  }
+  # File drop (screenshot tool saves to file then copies path)
+  if ($data.GetDataPresent([System.Windows.Forms.DataFormats]::FileDrop)) {
+    $files = [string[]]$data.GetData([System.Windows.Forms.DataFormats]::FileDrop)
+    foreach ($file in $files) {
+      if ($file -match '[.](png|jpg|jpeg|webp|gif)$' -and [System.IO.File]::Exists($file)) {
+        Emit-Bytes ([System.IO.File]::ReadAllBytes($file))
+      }
+    }
+  }
+}
+
+# Fallback: GetImage
+if ([System.Windows.Forms.Clipboard]::ContainsImage()) {
+  $img = [System.Windows.Forms.Clipboard]::GetImage()
+  if ($null -ne $img) {
+    $ms = New-Object System.IO.MemoryStream
+    try {
+      $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
+      Emit-Bytes $ms.ToArray()
+    } finally {
+      $ms.Dispose()
+      $img.Dispose()
+    }
+  }
+}
+exit 1
+`;
+    try {
+        const out = execFileSync("powershell.exe", ["-NoProfile", "-Command", "-"], {
+            input: script,
+            timeout: CLIPBOARD_TIMEOUT_MS,
+            maxBuffer: CLIPBOARD_MAX_BUFFER,
+            windowsHide: true,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (out.length > 0)
+            return out;
+    }
+    catch {
+        // PowerShell failed
+    }
+    return null;
+}
+/**
+ * Read an image from the system clipboard. Returns null if clipboard is empty
+ * or contains no image. Platform-specific: macOS (pngpaste/osascript), Linux
+ * (xclip/wl-paste), Windows (PowerShell).
+ */
+export function readClipboardImage(platform = process.platform) {
+    switch (platform) {
+        case "darwin": return readMacClipboard();
+        case "linux": return readLinuxClipboard();
+        case "win32": return readWindowsClipboard();
+        default: return null;
+    }
+}
+// ── High-level API ──────────────────────────────────────────────────────────
+/**
+ * Read clipboard image, validate, save to .omk/screenshots/, and return
+ * both the file path and base64 data URI for wire protocol use.
+ */
+export function pasteClipboardImage(projectRoot) {
+    const buf = readClipboardImage();
+    if (!buf || buf.length === 0) {
+        return { ok: false, error: "No image found in clipboard" };
+    }
+    if (buf.length > MAX_IMAGE_BYTES) {
+        return { ok: false, error: `Clipboard image exceeds ${MAX_IMAGE_BYTES / (1024 * 1024)} MB` };
+    }
+    const ext = detectImageExt(buf);
+    if (!ext) {
+        return { ok: false, error: "Clipboard content is not a recognized image format (PNG/JPG/WebP/GIF)" };
+    }
+    const { fullPath, relativePath } = generatePath(projectRoot, ext);
+    writeFileSync(fullPath, buf);
+    const base64 = buf.toString("base64");
+    return {
+        ok: true,
+        path: fullPath,
+        relativePath: `./${relativePath}`,
+        dataUri: toDataUri(base64, ext),
+        base64,
+        ext,
+    };
+}
+/**
+ * Read an image file from disk, validate, and return base64 data URI.
+ * Used for --image <file> flag support.
+ */
+export function readImageFile(filePath) {
+    if (!existsSync(filePath)) {
+        return { ok: false, error: `File not found: ${filePath}` };
+    }
+    const buf = readFileSync(filePath);
+    if (buf.length > MAX_IMAGE_BYTES) {
+        return { ok: false, error: `File exceeds ${MAX_IMAGE_BYTES / (1024 * 1024)} MB` };
+    }
+    const ext = detectImageExt(buf);
+    if (!ext) {
+        return { ok: false, error: "File is not a recognized image format (PNG/JPG/WebP/GIF)" };
+    }
+    const base64 = buf.toString("base64");
+    return {
+        ok: true,
+        path: filePath,
+        dataUri: toDataUri(base64, ext),
+        base64,
+        ext,
+    };
+}

package/dist/util/first-run-star.d.ts

@@ -23,6 +23,7 @@ export interface StarPromptOptions {
     commandName?: string;
     prompt?: (repoUrl: string) => Promise<boolean>;
     starRepo?: (repoUrl: string) => Promise<void> | void;
+    openBrowser?: typeof openRepoInBrowser;
     now?: () => Date;
 }
 export declare function getStarPromptStatePath(homeDir?: string): string;
@@ -47,3 +48,11 @@ export declare function getStarPromptSummary(homeDir?: string): Promise<StarProm
 export declare function parseGitHubRepoSlug(repoUrl: string): string | null;
 export declare function checkGhAuth(): Promise<void>;
 export declare function starGitHubRepo(repoUrl: string): Promise<void>;
+export interface OpenRepoInBrowserOptions {
+    spawnFn?: typeof import("child_process").spawn;
+    platform?: NodeJS.Platform;
+    display?: string;
+    isTTY?: boolean;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function openRepoInBrowser(repoUrl: string, opts?: OpenRepoInBrowserOptions): Promise<boolean>;

package/dist/util/first-run-star.js

@@ -1,4 +1,4 @@
-import { execFile } from "child_process";
+import { execFile, spawn } from "child_process";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { dirname, join } from "path";
@@ -72,6 +72,7 @@ export async function maybeAskForGitHubStar(options) {
                 console.error(style.gray(`GitHub star failed: ${starError}`));
                 if (slug)
                     console.error(style.gray(`Visit ${style.cream(`https://github.com/${slug}`)} to star manually.`));
+                await (options.openBrowser ?? openRepoInBrowser)(repoUrl);
             }
         }
         await writeStarPromptState({
@@ -124,6 +125,7 @@ export async function maybeAskForGitHubStarAfterCommand(options) {
                 console.error(style.gray(`GitHub star failed: ${starError}`));
                 if (slug)
                     console.error(style.gray(`Visit ${style.cream(`https://github.com/${slug}`)} to star manually.`));
+                await (options.openBrowser ?? openRepoInBrowser)(repoUrl);
             }
         }
         await writeStarPromptState({
@@ -221,3 +223,42 @@ export async function starGitHubRepo(repoUrl) {
         timeout: 10_000,
     });
 }
+export async function openRepoInBrowser(repoUrl, opts) {
+    try {
+        const isTTY = opts?.isTTY ?? process.stdout.isTTY;
+        const env = opts?.env ?? process.env;
+        const platform = opts?.platform ?? process.platform;
+        if (!isTTY)
+            return false;
+        if (env.CI || env.GITHUB_ACTIONS)
+            return false;
+        const display = opts?.display ?? env.DISPLAY;
+        let cmd;
+        let args;
+        if (platform === "darwin") {
+            cmd = "open";
+            args = [repoUrl];
+        }
+        else if (platform === "win32") {
+            cmd = "cmd";
+            args = ["/c", "start", "", repoUrl];
+        }
+        else if (platform === "linux" && display) {
+            cmd = "xdg-open";
+            args = [repoUrl];
+        }
+        else {
+            return false;
+        }
+        const spawnFn = opts?.spawnFn ?? spawn;
+        const child = spawnFn(cmd, args, {
+            stdio: "ignore",
+            detached: true,
+        });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/util/terminal-input.d.ts

@@ -22,4 +22,24 @@ export interface TerminalInputState {
 }
 export declare function captureTerminalInputState(input?: TerminalInputLike): TerminalInputState;
 export declare function enableRawTerminalInput(input?: TerminalInputLike): TerminalInputState;
+/**
+ * Defensive re-validation of interactive stdin before a fresh readline takes
+ * ownership of the TTY.
+ *
+ * The first-run GitHub-star prompt (maybeAskForGitHubStarAtChatStart) and the
+ * update prompt (maybePromptForOmkUpdate) use @inquirer/prompts, which take
+ * over raw mode and run their own readline on process.stdin. On completion they
+ * can leave the shared interactive stdin explicitly paused
+ * (readableFlowing === false). A freshly created readline then observes an
+ * immediate EOF/'close' and the native chat loop exits with "Session ended".
+ *
+ * This helper only resumes a real TTY that was explicitly paused. Non-TTY
+ * stdin (pipes/EOF, CI, non-interactive callers) is intentionally left
+ * untouched so existing exit/EOF behavior is preserved. A fresh, never-started
+ * stream (readableFlowing === null) is also left alone so readline can manage
+ * its own initial resume without racing for the first byte.
+ *
+ * Returns true only when it actually resumed a paused interactive stream.
+ */
+export declare function resumeInteractiveInput(input?: TerminalInputLike): boolean;
 export declare function restoreTerminalInputState(input: TerminalInputLike | undefined, state: TerminalInputState): void;

package/dist/util/terminal-input.js

@@ -21,6 +21,38 @@ export function enableRawTerminalInput(input = process.stdin) {
     input.resume();
     return state;
 }
+/**
+ * Defensive re-validation of interactive stdin before a fresh readline takes
+ * ownership of the TTY.
+ *
+ * The first-run GitHub-star prompt (maybeAskForGitHubStarAtChatStart) and the
+ * update prompt (maybePromptForOmkUpdate) use @inquirer/prompts, which take
+ * over raw mode and run their own readline on process.stdin. On completion they
+ * can leave the shared interactive stdin explicitly paused
+ * (readableFlowing === false). A freshly created readline then observes an
+ * immediate EOF/'close' and the native chat loop exits with "Session ended".
+ *
+ * This helper only resumes a real TTY that was explicitly paused. Non-TTY
+ * stdin (pipes/EOF, CI, non-interactive callers) is intentionally left
+ * untouched so existing exit/EOF behavior is preserved. A fresh, never-started
+ * stream (readableFlowing === null) is also left alone so readline can manage
+ * its own initial resume without racing for the first byte.
+ *
+ * Returns true only when it actually resumed a paused interactive stream.
+ */
+export function resumeInteractiveInput(input = process.stdin) {
+    if (!input.isTTY)
+        return false;
+    if (input.readableFlowing !== false)
+        return false;
+    try {
+        input.resume();
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
 export function restoreTerminalInputState(input = process.stdin, state) {
     const externalDataOwnerAttached = input.listenerCount("data") > state.dataListenerCount;
     if (!externalDataOwnerAttached && state.wasTTY && typeof input.setRawMode === "function") {

package/dist/util/update-check.d.ts

@@ -21,9 +21,14 @@ export interface KimiUpdateStatus {
     fallbackInstallCmd: string;
     installScript: string;
 }
-export declare const OMK_NPM_PACKAGE_NAME = "@omk/cli";
+export declare const OMK_NPM_PACKAGE_NAME = "open-multi-agent-kit";
 type UpdatePromptEnv = Record<string, string | undefined>;
 export type OmkUpdatePromptChoice = "update-now" | "skip-version" | "remind-later";
+/**
+ * Returns true when `env.OMK_AUTO_UPDATE` is one of 1/true/yes/on/always
+ * (case-insensitive), indicating the user wants non-interactive auto-updates.
+ */
+export declare function resolveAutoUpdateMode(env: UpdatePromptEnv): boolean;
 export type OmkUpdatePromptDecisionReason = "disabled" | "ci" | "non-tty" | "not-outdated" | "missing-latest" | "skipped-version" | "remind-active" | "prompt";
 export type OmkUpdatePromptAction = Exclude<OmkUpdatePromptDecisionReason, "prompt"> | "suppressed" | "prompted-skip" | "prompted-remind" | "updated" | "update-failed" | "cancelled" | "timeout";
 export interface OmkUpdatePromptState {

package/dist/util/update-check.js

@@ -6,9 +6,17 @@ import { homedir } from "os";
 const CACHE_TTL_MS = 6 * 60 * 60 * 1000;
 const DEFAULT_UPDATE_REMIND_HOURS = 24;
 const UPDATE_PROMPT_TIMEOUT_MS = 30_000;
-export const OMK_NPM_PACKAGE_NAME = "@omk/cli";
+export const OMK_NPM_PACKAGE_NAME = "open-multi-agent-kit";
 const OMK_UPDATE_INSTALL_CMD = `npm i -g ${OMK_NPM_PACKAGE_NAME}`;
 const FALLBACK_INSTALL_SCRIPT = "Set KIMI_API_KEY and optionally KIMI_MODEL for direct Moonshot API access.";
+/**
+ * Returns true when `env.OMK_AUTO_UPDATE` is one of 1/true/yes/on/always
+ * (case-insensitive), indicating the user wants non-interactive auto-updates.
+ */
+export function resolveAutoUpdateMode(env) {
+    const raw = env.OMK_AUTO_UPDATE?.trim().toLowerCase();
+    return raw === "1" || raw === "true" || raw === "yes" || raw === "on" || raw === "always";
+}
 function getCachePath() {
     return join(homedir(), ".omk", "update-cache.json");
 }
@@ -120,6 +128,32 @@ export async function maybePromptForOmkUpdate(options = {}) {
     const isTTY = options.isTTY ?? Boolean(process.stdout.isTTY && process.stdin.isTTY);
     const isCI = options.isCI ?? (isTruthyCiValue(env.CI) || isTruthyCiValue(env.GITHUB_ACTIONS));
     const log = options.onLog ?? ((message) => console.log(message));
+    const autoUpdate = resolveAutoUpdateMode(env);
+    if (autoUpdate && !isCI && getUpdatePromptMode(env) !== "off") {
+        let updateStatus;
+        try {
+            updateStatus = options.status ?? await (options.checkUpdatesFn ?? checkUpdates)();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { action: "suppressed", shouldExit: false, message };
+        }
+        const latestVersion = updateStatus.omk.latest;
+        if (updateStatus.omk.outdated && latestVersion) {
+            log(`Auto-updating OMK to ${normalizeVersionForPrompt(latestVersion)} ...`);
+            const runUpdate = options.runUpdate ?? (() => runShell("npm", ["i", "-g", OMK_NPM_PACKAGE_NAME], { timeout: 120_000 }));
+            const updateResult = await runUpdate();
+            if (updateResult.failed) {
+                const detail = updateResult.stderr.trim() || updateResult.stdout.trim() || `exit ${updateResult.exitCode}`;
+                log(`Auto-update failed: ${detail}`);
+                log(`Manual update command: ${OMK_UPDATE_INSTALL_CMD}`);
+                return { action: "update-failed", shouldExit: true, exitCode: 1, version: latestVersion, message: detail };
+            }
+            log("OMK auto-update completed successfully. Restart omk chat to use the new version.");
+            return { action: "updated", shouldExit: true, exitCode: 0, version: latestVersion };
+        }
+        return { action: "not-outdated", shouldExit: false };
+    }
     const preflight = resolveOmkUpdatePromptState({
         status: null,
         env,

package/docs/2026-06-08/critical-issues.md

@@ -0,0 +1,20 @@
+# 2026-06-08 Critical Issues
+
+## Critical Init Status
+- No critical init artifacts were missing when this daily file was generated.
+### Missing critical artifacts
+- None detected.
+
+
+## Critical Artifacts Present
+- ✅ `AGENTS.md` — top-level operating contract
+- ✅ `.kimi/AGENTS.md` — Kimi-specific operating rules
+- ✅ `.omk/config.toml` — OMK project runtime settings
+- ✅ `.omk/agents/root.yaml` — root coordinator agent
+- ✅ `.kimi/mcp.json` — Kimi project MCP registry
+- ✅ `.omk/hooks/pre-shell-guard.sh` — destructive shell guard
+- ✅ `.omk/hooks/protect-secrets.sh` — secret write guard
+- ✅ `.omk/memory/graph-state.json` — local ontology graph database
+
+## Escalation Rule
+- Treat missing shell/secret guards, root agent config, MCP registry, or ontology graph as critical until restored.

package/docs/2026-06-08/improvements.md

@@ -0,0 +1,14 @@
+# 2026-06-08 Improvements
+
+## Current Improvement Backlog
+### Optional init/support artifacts to add or refresh
+- None detected.
+
+### Critical init artifacts currently blocking reliable chat startup
+- None detected.
+
+
+## Suggested Focus
+- Keep `omk chat` startup idempotent and non-destructive.
+- Prefer local graph memory for default ontology state.
+- Keep generated daily docs small, dated, and safe to edit by hand.

package/docs/2026-06-08/init-checklist.md

@@ -0,0 +1,25 @@
+# 2026-06-08 Required Init Checklist
+
+**Run ID:** chat-2026-06-07T16-16-01-461Z-1315
+**Ontology graph:** `.omk/memory/graph-state.json`
+
+## Required Artifacts
+- ✅ `AGENTS.md` — critical; top-level operating contract
+- ✅ `.kimi/AGENTS.md` — critical; Kimi-specific operating rules
+- ✅ `DESIGN.md` — support; design/brand source of truth
+- ✅ `.omk/config.toml` — critical; OMK project runtime settings
+- ✅ `.omk/agents/root.yaml` — critical; root coordinator agent
+- ✅ `.kimi/mcp.json` — critical; Kimi project MCP registry
+- ✅ `.omk/mcp.json` — support; legacy OMK MCP fallback
+- ✅ `.omk/lsp.json` — support; bundled TypeScript/Python LSP config
+- ✅ `.omk/hooks/pre-shell-guard.sh` — critical; destructive shell guard
+- ✅ `.omk/hooks/protect-secrets.sh` — critical; secret write guard
+- ✅ `.omk/memory/graph-state.json` — critical; local ontology graph database
+- ✅ `.kimi/skills` — support; Kimi skill directory
+- ✅ `.agents/skills` — support; portable skill directory
+
+## Recovery Command
+```bash
+omk init
+omk doctor
+```

package/docs/2026-06-08/plan.md

@@ -0,0 +1,20 @@
+# 2026-06-08 OMK Chat Plan
+
+**Run ID:** chat-2026-06-07T16-16-01-461Z-1315
+**Generated by:** omk chat bootstrap
+
+## Purpose
+- Start every chat with a dated workspace for planning, issue triage, and verification evidence.
+- Keep ontology-backed memory available before the root coordinator starts.
+- Make required init state visible without overwriting user-authored docs.
+
+## Today Plan
+1. Review `init-checklist.md` and resolve missing critical init artifacts first.
+2. Use `improvements.md` as the active improvement backlog.
+3. Use `critical-issues.md` for blocking defects, safety risks, and verification gaps.
+4. Record command evidence before claiming work is complete.
+
+## Stop Condition
+- Critical init artifacts are present.
+- Ontology graph exists at `.omk/memory/graph-state.json`.
+- Any new code/docs changes have explicit verification evidence.

package/docs/2026-06-09/critical-issues.md

@@ -0,0 +1,20 @@
+# 2026-06-09 Critical Issues
+
+## Critical Init Status
+- No critical init artifacts were missing when this daily file was generated.
+### Missing critical artifacts
+- None detected.
+
+
+## Critical Artifacts Present
+- ✅ `AGENTS.md` — top-level operating contract
+- ✅ `.kimi/AGENTS.md` — Kimi-specific operating rules
+- ✅ `.omk/config.toml` — OMK project runtime settings
+- ✅ `.omk/agents/root.yaml` — root coordinator agent
+- ✅ `.kimi/mcp.json` — Kimi project MCP registry
+- ✅ `.omk/hooks/pre-shell-guard.sh` — destructive shell guard
+- ✅ `.omk/hooks/protect-secrets.sh` — secret write guard
+- ✅ `.omk/memory/graph-state.json` — local ontology graph database
+
+## Escalation Rule
+- Treat missing shell/secret guards, root agent config, MCP registry, or ontology graph as critical until restored.

package/docs/2026-06-09/improvements.md

@@ -0,0 +1,14 @@
+# 2026-06-09 Improvements
+
+## Current Improvement Backlog
+### Optional init/support artifacts to add or refresh
+- None detected.
+
+### Critical init artifacts currently blocking reliable chat startup
+- None detected.
+
+
+## Suggested Focus
+- Keep `omk chat` startup idempotent and non-destructive.
+- Prefer local graph memory for default ontology state.
+- Keep generated daily docs small, dated, and safe to edit by hand.

package/docs/2026-06-09/init-checklist.md

@@ -0,0 +1,25 @@
+# 2026-06-09 Required Init Checklist
+
+**Run ID:** chat-2026-06-09T00-01-07-440Z-28177
+**Ontology graph:** `.omk/memory/graph-state.json`
+
+## Required Artifacts
+- ✅ `AGENTS.md` — critical; top-level operating contract
+- ✅ `.kimi/AGENTS.md` — critical; Kimi-specific operating rules
+- ✅ `DESIGN.md` — support; design/brand source of truth
+- ✅ `.omk/config.toml` — critical; OMK project runtime settings
+- ✅ `.omk/agents/root.yaml` — critical; root coordinator agent
+- ✅ `.kimi/mcp.json` — critical; Kimi project MCP registry
+- ✅ `.omk/mcp.json` — support; legacy OMK MCP fallback
+- ✅ `.omk/lsp.json` — support; bundled TypeScript/Python LSP config
+- ✅ `.omk/hooks/pre-shell-guard.sh` — critical; destructive shell guard
+- ✅ `.omk/hooks/protect-secrets.sh` — critical; secret write guard
+- ✅ `.omk/memory/graph-state.json` — critical; local ontology graph database
+- ✅ `.kimi/skills` — support; Kimi skill directory
+- ✅ `.agents/skills` — support; portable skill directory
+
+## Recovery Command
+```bash
+omk init
+omk doctor
+```

package/docs/2026-06-09/plan.md

@@ -0,0 +1,20 @@
+# 2026-06-09 OMK Chat Plan
+
+**Run ID:** chat-2026-06-09T00-01-07-440Z-28177
+**Generated by:** omk chat bootstrap
+
+## Purpose
+- Start every chat with a dated workspace for planning, issue triage, and verification evidence.
+- Keep ontology-backed memory available before the root coordinator starts.
+- Make required init state visible without overwriting user-authored docs.
+
+## Today Plan
+1. Review `init-checklist.md` and resolve missing critical init artifacts first.
+2. Use `improvements.md` as the active improvement backlog.
+3. Use `critical-issues.md` for blocking defects, safety risks, and verification gaps.
+4. Record command evidence before claiming work is complete.
+
+## Stop Condition
+- Critical init artifacts are present.
+- Ontology graph exists at `.omk/memory/graph-state.json`.
+- Any new code/docs changes have explicit verification evidence.