@nanhara/hara 0.119.2 → 0.121.0

package/CHANGELOG.md

@@ -5,6 +5,38 @@ All notable changes to `@nanhara/hara`.
 > Versioning (pre-1.0, SemVer-style): the **minor** (middle) number bumps for a **new feature**; the
 > **patch** (last) number bumps for **optimizations/fixes of existing features**.
 
+## 0.121.0 — `hara desk` · crash-safe coding/files · bounded interactive I/O
+
+- **`hara desk` connects the CLI to the shared coordination desk.** Register an agent, post/list/
+  claim/complete/ack/cancel tasks, and persist the desk token with owner-only file permissions. The
+  client identifies itself as `hara-cli`, so mixed Codex/Claude Code/hara fleets remain legible.
+- **Coding edits are transaction-safe.** `write_file` uses same-directory atomic replacement;
+  multi-file patches validate every destination before writing and roll back already-committed
+  files if a later commit fails. Undo snapshots are captured before mutation, failed writes do not
+  create false undo history, and symlink/non-regular destinations are rejected consistently.
+- **Large files stay useful without flooding memory or context.** Slice reads stream only the
+  requested line window, `@file` mentions have explicit byte/line caps, and tool results are
+  bounded centrally (including plugin/MCP results) with clear truncation metadata.
+- **Interactive input is friendlier and bounded.** The TUI composer has shell-style up/down history
+  with draft restoration, duplicate suppression, navigation reset after edits, and a fixed maximum
+  history size. The ask-mode sentinel is also source-safe on every supported Node runtime.
+- **Faster cold start.** Unicode-width data and the write/edit tool graph are loaded only when the
+  active command needs them, reducing startup work for lightweight commands such as `--version`.
+- **Production dependency hardening.** The Lark SDK's Axios transport is pinned to a patched 1.x
+  release instead of its vulnerable `~1.13.3` range; the production npm audit is clean at release.
+
+## 0.120.0 — `hara feedback`: one door for humans and agents
+
+- **`hara feedback "what happened"`** files a structured GitHub issue (repo hara-cli/hara,
+  label `feedback`) via the gh CLI, with a copy-paste fallback. Auto-collects hara version /
+  OS / Node / provider:model (never keys) and aggressively redacts credentials
+  (sk-/ghp_/AWS/Bearer/JWT/key=value families). `--session` opt-in attaches a redacted session
+  tail (issues are public); `--dry-run` prints without filing. Matching .github issue forms
+  ship in the repo — hand-filed and command-filed reports read identically.
+- **Security stance (documented)**: hara agents exchange structured data — they never accept
+  task instructions from untrusted parties. Cross-trust-boundary agent task-passing is
+  permanently out of scope; feedback/issues are the entire agent-to-agent surface.
+
 ## 0.119.2 — TUI: update notices actually visible · CJK-correct input wrapping
 
 - **Update notices now render INSIDE the TUI** (yellow line under the header card). They used to

package/dist/context/mentions.js

@@ -1,10 +1,11 @@
 // @file mentions — expand `@path` references in user input into appended file contents,
 // and provide fuzzy file candidates for REPL tab-completion.
-import { readFileSync, existsSync, statSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
 import { listProjectFiles, dirPrefixes, walkFiles } from "../fs-walk.js";
 import { fuzzyRank } from "../fuzzy.js";
 import { mediaTypeFor } from "../images.js";
+import { readTextPrefixSync } from "../fs-read.js";
 const MAX_FILE = 50_000;
 // @ at start-of-string or after whitespace; capture a path with no spaces/@ (avoids emails like a@b.com)
 const MENTION_RE = /(?:^|\s)@([^\s@]+)/g;
@@ -53,9 +54,10 @@ function expandRef(ref, cwd) {
             // don't inline binary image bytes as text — paste with Ctrl+V (or drag the file in) to attach visually
             if (mediaTypeFor(abs))
                 return `Referenced \`${ref}\` is an image — paste it with Ctrl+V to attach it visually.`;
-            let txt = readFileSync(abs, "utf8");
-            if (txt.length > MAX_FILE)
-                txt = txt.slice(0, MAX_FILE) + "\n…[truncated]";
+            const prefix = readTextPrefixSync(abs, MAX_FILE);
+            if (prefix.binary)
+                return `Referenced \`${ref}\` appears to be binary — it was not inserted into the model context.`;
+            const txt = prefix.text + (prefix.truncated ? "\n…[truncated]" : "");
             return `\nReferenced file \`${ref}\`:\n\`\`\`\n${txt}\n\`\`\`\n`;
         }
         if (st.isDirectory()) {
@@ -73,16 +75,24 @@ function expandRef(ref, cwd) {
 const cache = new Map();
 const CACHE_MS = 5000;
 function projectEntries(cwd) {
-    const hit = cache.get(cwd);
+    const key = resolve(cwd);
+    const hit = cache.get(key);
     const now = Date.now();
     if (hit && now - hit.at < CACHE_MS)
         return hit.entries;
-    const files = listProjectFiles(cwd);
+    const files = listProjectFiles(key);
     // files + their directory prefixes (so `@src/` drills into the subtree)
     const entries = [...dirPrefixes(files), ...files];
-    cache.set(cwd, { at: now, entries });
+    cache.set(key, { at: now, entries });
     return entries;
 }
+/** Invalidate the derived @path inventory after a coding tool creates/deletes a file. */
+export function invalidateFileCandidates(cwd) {
+    if (cwd)
+        cache.delete(resolve(cwd));
+    else
+        cache.clear();
+}
 /**
  * File/dir candidates whose path matches `query`, for @ autocomplete.
  * Recurses subdirectories (git-tracked + untracked, or a filesystem walk outside git),

package/dist/desk.js

@@ -0,0 +1,64 @@
+// `hara desk` client — how a hara agent connects to the hara-desk coordination server (the closed-
+// source identity registry + task board). This is the OPEN-SOURCE side of the wire: a thin HTTP
+// client + local credential storage. The desk itself (auth, board, L2 ack) lives in hara-desk.
+//
+// Credentials live in ~/.hara/desk.json (0600): the desk URL + this agent's token, written once at
+// `hara desk register`. Every later call reads them back. The token is a bearer secret — never logged.
+import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const credsPath = () => join(homedir(), ".hara", "desk.json");
+export function loadCreds() {
+    try {
+        const c = JSON.parse(readFileSync(credsPath(), "utf8"));
+        return c.url && c.token ? c : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCreds(c) {
+    const dir = join(homedir(), ".hara");
+    mkdirSync(dir, { recursive: true });
+    const p = credsPath();
+    writeFileSync(p, JSON.stringify(c, null, 2));
+    try {
+        chmodSync(p, 0o600);
+    }
+    catch {
+        /* best-effort on non-posix */
+    }
+}
+/** One HTTP call to the desk. Auth via bearer token when creds are present. Throws on non-2xx with
+ *  the server's error message (so the CLI can surface a real reason, not "request failed"). */
+export async function deskCall(url, method, path, opts = {}) {
+    const r = await fetch(url.replace(/\/$/, "") + path, {
+        method,
+        headers: {
+            "content-type": "application/json",
+            ...(opts.token ? { authorization: `Bearer ${opts.token}` } : {}),
+        },
+        ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
+        signal: AbortSignal.timeout(opts.timeoutMs ?? 10000),
+    });
+    const text = await r.text();
+    let data = {};
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch {
+        data = { raw: text };
+    }
+    if (!r.ok)
+        throw new Error(data?.error || `desk ${r.status}: ${text.slice(0, 200)}`);
+    return data;
+}
+/** Register this machine's agent with a desk and persist the returned credentials. `client`
+ *  identifies the kind of client (defaults "hara-cli"); the desk is client-agnostic, so any agent
+ *  may pass its own label. */
+export async function registerAgent(url, enrollKey, name, owner, client = "hara-cli") {
+    const r = await deskCall(url, "POST", "/register", { body: { enrollKey, name, owner, client } });
+    const creds = { url, agentId: r.agentId, owner: r.owner, token: r.token };
+    saveCreds(creds);
+    return creds;
+}

package/dist/feedback.js

@@ -0,0 +1,55 @@
+// `hara feedback` — the hara-hub verdict made flesh: feedback is a COMMAND, not a server.
+// Collects environment facts, redacts secrets, and builds a structured GitHub issue body that
+// humans and agents file through the same door (gh CLI when present, copy-paste text otherwise).
+// The session tail is OFF by default and explicitly opt-in (--session) because issues are public.
+import { platform, release, arch } from "node:os";
+export function collectEnv(version, model) {
+    return {
+        version,
+        os: `${platform()} ${release()} ${arch()}`,
+        node: process.version,
+        model,
+    };
+}
+/** Strip credential-looking material from text that is about to become a PUBLIC issue.
+ *  Deliberately aggressive: false positives cost a little readability, false negatives leak keys. */
+export function redact(text) {
+    return text
+        .replace(/\bsk-[A-Za-z0-9_-]{8,}/g, "sk-***")
+        .replace(/\bgh[pousr]_[A-Za-z0-9]{20,}/g, "gh*_***")
+        .replace(/\b(AKIA|ASIA)[A-Z0-9]{16}\b/g, "AWS-KEY-***")
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/gi, "Bearer ***")
+        .replace(/\b(api[_-]?key|apikey|token|secret|password|passwd|authorization)(["']?\s*[:=]\s*["']?)[^\s"',;]{6,}/gi, "$1$2***")
+        .replace(/\beyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, "JWT-***");
+}
+/** The structured issue body — same shape as .github/ISSUE_TEMPLATE/bug_report.yml so hand-filed
+ *  and command-filed issues read identically to the triage side. */
+export function buildIssueBody(description, env, sessionTail) {
+    const parts = [
+        "## What happened",
+        "",
+        redact(description.trim() || "(no description provided)"),
+        "",
+        "## Environment",
+        "",
+        "| | |",
+        "|---|---|",
+        `| hara | ${env.version} |`,
+        `| os | ${env.os} |`,
+        `| node | ${env.node} |`,
+        ...(env.model ? [`| model | ${redact(env.model)} |`] : []),
+        "",
+    ];
+    if (sessionTail && sessionTail.trim()) {
+        parts.push("## Session tail (redacted, shared with --session)", "", "```", redact(sessionTail).slice(0, 4000), "```", "");
+    }
+    parts.push("---", "_filed via `hara feedback`_");
+    return parts.join("\n");
+}
+/** Issue title from the description: first line, trimmed, capped. */
+export function issueTitle(description) {
+    const first = (description.trim().split("\n")[0] || "feedback").trim();
+    return first.length > 70 ? first.slice(0, 67) + "…" : first;
+}
+export const FEEDBACK_REPO = "hara-cli/hara";
+export const NEW_ISSUE_URL = `https://github.com/${FEEDBACK_REPO}/issues/new`;

package/dist/fs-read.js

@@ -0,0 +1,157 @@
+// Bounded streaming line reader for files too large to load as one string. It stores only the requested
+// window and a capped prefix of each line, so huge logs/JSONL and minified one-line files stay safe.
+import { closeSync, createReadStream, fstatSync, openSync, readSync } from "node:fs";
+export class BinaryFileError extends Error {
+    constructor(path) {
+        super(`${path} appears to be binary (NUL byte detected)`);
+        this.name = "BinaryFileError";
+    }
+}
+const DEFAULT_LINE_CAP = 2000;
+const DEFAULT_MAX_SCAN = 64 * 1024 * 1024;
+/** Read only enough bytes to produce a bounded UTF-8 prefix (used by synchronous @file expansion). */
+export function readTextPrefixSync(path, maxChars) {
+    const chars = Math.max(0, Math.floor(maxChars));
+    const fd = openSync(path, "r");
+    try {
+        const size = fstatSync(fd).size;
+        // Four bytes per Unicode scalar plus a small boundary cushion guarantees enough decoded input for
+        // `chars` without allocating the entire file. readSync can short-read, so fill in a loop.
+        const byteLimit = Math.min(size, chars * 4 + 4);
+        const buffer = Buffer.allocUnsafe(byteLimit);
+        let read = 0;
+        while (read < byteLimit) {
+            const n = readSync(fd, buffer, read, byteLimit - read, read);
+            if (n === 0)
+                break;
+            read += n;
+        }
+        const bytes = buffer.subarray(0, read);
+        const binary = bytes.subarray(0, Math.min(bytes.length, 4096)).includes(0);
+        const decoded = binary ? "" : bytes.toString("utf8");
+        return {
+            text: decoded.slice(0, chars),
+            truncated: size > read || decoded.length > chars,
+            binary,
+        };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Render a line slice without retaining the entire file. Total line count is shown only when EOF is reached. */
+export async function streamFileSlice(path, offset = 1, limit = 300, options = {}) {
+    const start = Math.max(1, Math.floor(offset));
+    const want = Math.max(1, Math.floor(limit));
+    const requestedEnd = start + want - 1;
+    const lineCap = Math.max(1, Math.floor(options.lineCap ?? DEFAULT_LINE_CAP));
+    const maxScan = Math.max(lineCap, Math.floor(options.maxScanChars ?? DEFAULT_MAX_SCAN));
+    const rendered = [];
+    let lineNo = 1;
+    let linePrefix = "";
+    let lineChars = 0;
+    let lineEndsWithCr = false;
+    let sawData = false;
+    let endedWithNewline = false;
+    let scanned = 0;
+    let hasMore = false;
+    let scanLimited = false;
+    let stoppedEarly = false;
+    const append = (part) => {
+        if (!part.length)
+            return;
+        sawData = true;
+        endedWithNewline = false;
+        if (lineNo > requestedEnd) {
+            hasMore = true;
+            return;
+        }
+        if (lineNo >= start) {
+            lineChars += part.length;
+            if (linePrefix.length < lineCap)
+                linePrefix += part.slice(0, lineCap - linePrefix.length);
+            lineEndsWithCr = part.endsWith("\r");
+        }
+    };
+    const finishLine = (partial = false) => {
+        const current = lineNo;
+        if (current >= start && current <= requestedEnd) {
+            let chars = lineChars;
+            let prefix = linePrefix;
+            if (!partial && lineEndsWithCr) {
+                chars = Math.max(0, chars - 1);
+                if (prefix.endsWith("\r"))
+                    prefix = prefix.slice(0, -1);
+            }
+            const omitted = Math.max(0, chars - prefix.length);
+            const tail = partial
+                ? `…[line continues; scan stopped after ${scanned} chars]`
+                : omitted
+                    ? `…[+${omitted} chars]`
+                    : "";
+            rendered.push(`${String(current).padStart(6)}\t${prefix}${tail}`);
+        }
+        lineNo++;
+        linePrefix = "";
+        lineChars = 0;
+        lineEndsWithCr = false;
+        if (current > requestedEnd)
+            hasMore = true;
+    };
+    const stream = createReadStream(path, { encoding: "utf8", highWaterMark: 64 * 1024 });
+    try {
+        for await (const raw of stream) {
+            const chunk = String(raw);
+            if (chunk.length)
+                sawData = true;
+            if (scanned < 4096 && chunk.slice(0, 4096 - scanned).includes("\0"))
+                throw new BinaryFileError(path);
+            scanned += chunk.length;
+            let at = 0;
+            while (at < chunk.length) {
+                const newline = chunk.indexOf("\n", at);
+                if (newline < 0) {
+                    append(chunk.slice(at));
+                    break;
+                }
+                append(chunk.slice(at, newline));
+                finishLine();
+                endedWithNewline = true;
+                at = newline + 1;
+                if (hasMore)
+                    break;
+            }
+            if (hasMore) {
+                stoppedEarly = true;
+                break;
+            }
+            if (scanned >= maxScan) {
+                scanLimited = true;
+                stoppedEarly = true;
+                if (lineNo >= start && lineNo <= requestedEnd)
+                    finishLine(true);
+                break;
+            }
+        }
+    }
+    finally {
+        stream.destroy();
+    }
+    if (!stoppedEarly) {
+        // A trailing newline creates no phantom line, matching String#split + trailing-empty removal.
+        if (!endedWithNewline || !sawData)
+            finishLine();
+        const total = lineNo - 1;
+        if (start > total)
+            return `(file has ${total} lines — offset ${start} is past the end)`;
+        const end = start + rendered.length - 1;
+        const sliced = start > 1 || end < total;
+        const head = sliced ? `(lines ${start}–${end} of ${total}${end < total ? ` — continue with offset:${end + 1}` : ""})\n` : "";
+        return head + rendered.join("\n");
+    }
+    const end = start + Math.max(0, rendered.length - 1);
+    if (scanLimited) {
+        return `(large file scan stopped after ${scanned} chars — use grep or bash byte-range tools for a narrower target)\n${rendered.join("\n")}`;
+    }
+    return `(lines ${start}–${end}; more lines follow — continue with offset:${end + 1})\n${rendered.join("\n")}`;
+}

package/dist/fs-write.js

@@ -0,0 +1,105 @@
+// Crash-safe UTF-8 writes for coding tools. Content is staged beside the destination, fsynced, then
+// renamed into place so a killed process never leaves a half-written source file.
+import { dirname, join } from "node:path";
+import { link, lstat, mkdir, open, readFile, realpath, rename, stat, unlink } from "node:fs/promises";
+export class FileChangedError extends Error {
+    code = "HARA_FILE_CHANGED";
+    constructor(path) {
+        super(`File changed while the edit was being prepared: ${path}. Re-read it and retry the edit.`);
+        this.name = "FileChangedError";
+    }
+}
+let tempSequence = 0;
+async function writeTarget(path) {
+    try {
+        const info = await lstat(path);
+        // Replacing a symlink would silently break it. Stage beside the real target instead so edits retain
+        // the link (common in dotfile repos and generated workspace layouts).
+        if (info.isSymbolicLink())
+            return await realpath(path);
+    }
+    catch (error) {
+        if (error?.code !== "ENOENT")
+            throw error;
+    }
+    return path;
+}
+async function syncDirectory(path) {
+    // Directory fsync makes the rename durable across a power loss on POSIX. Some filesystems/platforms
+    // reject opening directories, so durability degrades gracefully after the file itself was synced.
+    try {
+        const handle = await open(path, "r");
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        /* best effort */
+    }
+}
+/** Atomically replace/create a UTF-8 file, optionally refusing to overwrite a newer disk version. */
+export async function atomicWriteText(path, content, options = {}) {
+    const target = await writeTarget(path);
+    const dir = dirname(target);
+    await mkdir(dir, { recursive: true });
+    let mode = 0o666;
+    try {
+        mode = (await stat(target)).mode & 0o777;
+    }
+    catch (error) {
+        if (error?.code !== "ENOENT")
+            throw error;
+    }
+    // Keep the staging basename fixed-size: prefixing the destination's full basename would make a
+    // perfectly valid near-NAME_MAX file impossible to edit because the temporary name becomes longer.
+    const temp = join(dir, `.hara-${process.pid}-${Date.now().toString(36)}-${tempSequence++}.tmp`);
+    let staged = false;
+    try {
+        const handle = await open(temp, "wx", mode);
+        staged = true;
+        try {
+            await handle.writeFile(content, "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        if (options.expected === null) {
+            // link(2) is an atomic create-if-absent operation. A plain rename would overwrite a file that
+            // appeared after validation, defeating create's no-clobber contract.
+            try {
+                await link(temp, target);
+            }
+            catch (error) {
+                if (error?.code === "EEXIST")
+                    throw new FileChangedError(path);
+                throw error;
+            }
+            await unlink(temp);
+            staged = false;
+        }
+        else {
+            if (typeof options.expected === "string") {
+                let current;
+                try {
+                    current = await readFile(target, "utf8");
+                }
+                catch {
+                    throw new FileChangedError(path);
+                }
+                if (current !== options.expected)
+                    throw new FileChangedError(path);
+            }
+            await rename(temp, target);
+            staged = false;
+        }
+        await syncDirectory(dir);
+    }
+    finally {
+        if (staged)
+            await unlink(temp).catch(() => { });
+    }
+}

package/dist/index.js

@@ -1990,6 +1990,140 @@ rolesCmd.action(() => {
         out(`${c.bold(r.id)}${r.model ? c.dim(` (${r.model})`) : ""}  ${c.dim("owns: " + r.owns.join(", "))}\n  ${r.description}\n`);
     }
 });
+program
+    .command("feedback [description...]")
+    .description("file a structured bug/feature report to GitHub (hara-cli/hara) — humans and agents use the same door")
+    .option("--session", "append a REDACTED tail of the most recent session (the issue is PUBLIC)")
+    .option("--dry-run", "print the issue body without filing")
+    .action(async (parts, o) => {
+    // the hara-hub verdict: feedback is a command, not a server — GitHub Issues is the bus
+    const { collectEnv, buildIssueBody, issueTitle, FEEDBACK_REPO, NEW_ISSUE_URL } = await import("./feedback.js");
+    const desc = (parts ?? []).join(" ").trim();
+    if (!desc) {
+        out(`Usage: hara feedback "what happened…" [--session] [--dry-run] — files a structured issue to ${FEEDBACK_REPO}\n`);
+        return;
+    }
+    let tail;
+    if (o.session) {
+        const { listSessions, loadSession } = await import("./session/store.js");
+        const metas = listSessions();
+        const last = metas[0] ? loadSession(metas[0].id) : null;
+        if (last) {
+            tail = last.history
+                .slice(-8)
+                .map((m) => (m.role === "user" ? `user: ${m.content}` : m.role === "assistant" && m.text ? `assistant: ${m.text}` : ""))
+                .filter(Boolean)
+                .join("\n")
+                .slice(-3000);
+            out(c.yellow("⚠ --session attaches a redacted tail of your last session to a PUBLIC issue.\n"));
+        }
+    }
+    const { readRawConfig } = await import("./config.js");
+    const raw = readRawConfig();
+    const modelLabel = raw.provider && raw.model ? `${raw.provider}:${raw.model}` : undefined;
+    const body = buildIssueBody(desc, collectEnv(pkg.version, modelLabel), tail);
+    if (o.dryRun) {
+        out(body + "\n");
+        return;
+    }
+    const { execFileSync } = await import("node:child_process");
+    try {
+        execFileSync("gh", ["--version"], { stdio: "ignore" });
+        const url = execFileSync("gh", ["issue", "create", "--repo", FEEDBACK_REPO, "--title", issueTitle(desc), "--body", body, "--label", "feedback"], { encoding: "utf8" });
+        out(c.green("✓ filed: ") + url.trim() + "\n");
+    }
+    catch {
+        out(`\n(gh CLI unavailable or filing failed — copy everything below into ${NEW_ISSUE_URL})\n\n# ${issueTitle(desc)}\n\n${body}\n`);
+    }
+});
+// `hara desk` — connect to a hara-desk coordination server (identity registry + task board).
+// The desk is the closed-source enterprise piece; this is the open-source client side.
+const deskCmd = program.command("desk").description("coordinate with a hara-desk server (register · post · board · claim · complete)");
+deskCmd
+    .command("register")
+    .description("register this agent with a desk and save credentials to ~/.hara/desk.json")
+    .requiredOption("--url <url>", "desk base URL (e.g. http://127.0.0.1:4200)")
+    .requiredOption("--key <enrollKey>", "the desk's enroll key")
+    .option("--name <name>", "agent name shown in the registry", "hara-cli")
+    .option("--owner <owner>", "the human this agent belongs to", "me")
+    .action(async (o) => {
+    const { registerAgent } = await import("./desk.js");
+    try {
+        const creds = await registerAgent(o.url, o.key, o.name, o.owner);
+        out(c.green("✓ registered ") + `${creds.agentId} (owner ${creds.owner}) → ${creds.url}\n`);
+    }
+    catch (e) {
+        out(c.red(`register failed: ${e.message}\n`));
+    }
+});
+deskCmd
+    .command("post [title...]")
+    .description("post a task or feedback report to the board")
+    .option("--dispatch", "a dispatch task (someone does work) instead of a feedback report")
+    .option("--high", "high-risk dispatch (needs an owner ack before it can complete)")
+    .option("--body <text>", "task body / details", "")
+    .action(async (parts, o) => {
+    const { loadCreds, deskCall } = await import("./desk.js");
+    const creds = loadCreds();
+    if (!creds)
+        return void out(c.red("not registered — run `hara desk register --url … --key …` first\n"));
+    const title = (parts ?? []).join(" ").trim();
+    if (!title)
+        return void out("Usage: hara desk post <title> [--dispatch] [--high] [--body …]\n");
+    try {
+        const r = await deskCall(creds.url, "POST", "/tasks", { token: creds.token, body: { kind: o.dispatch ? "dispatch" : "feedback", risk: o.high ? "high" : "low", title, body: o.body } });
+        out(c.green("✓ posted ") + `${r.task.id} (${r.task.kind}/${r.task.state})\n`);
+    }
+    catch (e) {
+        out(c.red(`post failed: ${e.message}\n`));
+    }
+});
+deskCmd
+    .command("board")
+    .description("list the board (default: open tasks)")
+    .option("--state <state>", "open | claimed | done | cancelled", "open")
+    .option("--kind <kind>", "feedback | dispatch")
+    .action(async (o) => {
+    const { loadCreds, deskCall } = await import("./desk.js");
+    const creds = loadCreds();
+    if (!creds)
+        return void out(c.red("not registered — run `hara desk register` first\n"));
+    try {
+        const q = `/tasks?state=${encodeURIComponent(o.state)}${o.kind ? `&kind=${encodeURIComponent(o.kind)}` : ""}`;
+        const r = await deskCall(creds.url, "GET", q, { token: creds.token });
+        if (!r.tasks.length)
+            return void out(c.dim("(board empty)\n"));
+        for (const t of r.tasks)
+            out(`${t.id}  ${c.bold(t.kind)}${t.risk === "high" ? c.red("!") : " "} ${t.state.padEnd(8)} ${t.title}\n`);
+    }
+    catch (e) {
+        out(c.red(`board failed: ${e.message}\n`));
+    }
+});
+for (const [verb, path, ok] of [
+    ["claim", "claim", "claimed"],
+    ["complete", "complete", "completed"],
+    ["ack", "ack", "acked"],
+    ["cancel", "cancel", "cancelled"],
+]) {
+    deskCmd
+        .command(`${verb} <taskId>`)
+        .description(`${verb} a task`)
+        .option("--detail <text>", "note (complete)", "")
+        .action(async (taskId, o) => {
+        const { loadCreds, deskCall } = await import("./desk.js");
+        const creds = loadCreds();
+        if (!creds)
+            return void out(c.red("not registered — run `hara desk register` first\n"));
+        try {
+            const r = await deskCall(creds.url, "POST", `/tasks/${taskId}/${path}`, { token: creds.token, body: verb === "complete" ? { detail: o.detail } : {} });
+            out(c.green(`✓ ${ok} `) + `${r.task?.id ?? taskId}${r.task ? ` (${r.task.state})` : ""}\n`);
+        }
+        catch (e) {
+            out(c.red(`${verb} failed: ${e.message}\n`));
+        }
+    });
+}
 const skillsCmd = program.command("skills").description("manage skills (.hara/skills/<name>/SKILL.md)");
 skillsCmd
     .command("init")