@nanhara/hara 0.89.0 → 0.95.2

package/dist/session/session-model.js

@@ -0,0 +1,36 @@
+// Session-level model selection — small module so the four role-provider call sites in index.ts
+// (runOrg / executeAtom / review-chain / runSubagent) can consult "is the user forcing all roles
+// to the session model?" without importing index.ts. The state is plain process-local, reset
+// between processes (we never persist `--force` across runs — only the session-pinned model).
+//
+// Priority chain (highest first):
+//   /model X --force  (this session, all roles)  ← sessionForceModel === true
+//   /model X          (this session, defaults respect role.model)
+//   --model X         (CLI flag, written into meta.model)
+//   meta.model        (resume; restored into cfg.model at startup)
+//   role.model        (org role frontmatter — respected by default)
+//   profile.model / defaultModel / provider default
+let _forced = false;
+/** Switch on/off "force all roles to use the session model" for this process. */
+export function setSessionForceModel(on) {
+    _forced = !!on;
+}
+/** Is the session-force flag on? */
+export function isSessionForceModel() {
+    return _forced;
+}
+/** Resolve the model a role should run under given current force state.
+ *  - default (no --force): role's frontmatter model wins if set, else fall back to session model.
+ *  - with --force: session model wins, role.model is ignored.
+ *  Returns undefined when there's no override needed (role.model is unset OR equals cfg.model OR
+ *  force is on AND we should rebuild with cfg.model only when role.model would otherwise have
+ *  switched providers — i.e. callers should still gate "rebuild provider only if different"). */
+export function effectiveRoleModel(roleModel, sessionModel) {
+    if (_forced)
+        return undefined; // force → use the session/base provider, ignore role.model entirely
+    if (!roleModel)
+        return undefined;
+    if (roleModel === sessionModel)
+        return undefined;
+    return roleModel;
+}

package/dist/statusbar.js

@@ -21,11 +21,20 @@ export function contextWindow(model) {
     return 200_000;
 }
 export const ctxPctFor = (model, lastInput) => lastInput > 0 ? Math.min(99, Math.round((lastInput / contextWindow(model)) * 100)) : 0;
-/** Top border with the session name in the right corner: `────────── ⏺ session ─` */
+/** Top border with the session name in the right corner: `────── [profile] ⏺ session ─`.
+ *  The profile chip on the left flank surfaces "which identity am I as right now". gateway
+ *  profiles get a cyan ORG badge (drawing the eye — your traffic is going somewhere else),
+ *  personal/byok profiles get a dim badge so they fade into the background. */
 export function borderTop(s, cols) {
     const name = truncate(s.sessionName || "new session", Math.max(8, cols - 14));
-    const label = `${c.cyan("⏺")} ${c.bold(name)}`;
-    return rule(cols - vlen(label) - 3) + " " + label + " " + rule(1);
+    const right = `${c.cyan("⏺")} ${c.bold(name)}`;
+    const chip = s.profileId
+        ? (s.profileKind === "gateway" ? c.cyan(`[${s.profileId} · ORG]`) : c.dim(`[${s.profileId}]`))
+        : "";
+    const left = chip ? chip + " " : "";
+    const innerLen = vlen(left) + vlen(right);
+    const pad = Math.max(0, cols - innerLen - 4);
+    return rule(1) + " " + left + rule(pad) + " " + right + " " + rule(1);
 }
 /** Bottom border carrying mode · tokens · concurrency: `── ◆suggest auto-edit full-auto · ↑0 ↓0 · ⛁ ──` */
 export function borderBottom(s, cols, agents) {

package/dist/tools/external_agent.js

@@ -0,0 +1,118 @@
+// external_agent — delegate a self-contained task to an EXTERNAL coding-agent CLI (claude-code / codex / …)
+// running headless on the host, and return its final text. Inspired by openclaw's ACP subagent feature, but
+// zero-dep: we drive each agent's native headless flag (`claude -p`, `codex exec`) over node:child_process
+// instead of the heavy ACP/acpx stack.
+//
+// Safety: kind:"exec" → inherits the loop's approval gate. It can read/write/run on the host, so it is the most
+// privileged tool — and because fan-out sub-agents only get the read-only allow-list (READONLY_TOOLS), they
+// never see this tool. Trust tiers (off|gated|full) gate the dangerous bypass/full-access sub-modes.
+import { spawn, execFileSync } from "node:child_process";
+import { registerTool } from "./registry.js";
+import { capHeadTail } from "./builtin.js";
+import { loadConfig } from "../config.js";
+/** Pure: build the spawn (cmd, args) for a backend, or null if unknown. Maps hara's sandbox/trust → the agent's
+ *  own permission flags; the dangerous bypass/full-access modes are only reachable at trust "full". */
+export function buildExternalArgv(backend, task, o) {
+    if (backend === "claude") {
+        const mode = o.trust === "full" ? "bypassPermissions" : o.sandbox === "workspace-write" ? "acceptEdits" : "plan";
+        return { cmd: "claude", args: ["-p", task, "--output-format", "text", ...(o.model ? ["--model", o.model] : []), "--permission-mode", mode] };
+    }
+    if (backend === "codex") {
+        const sb = o.trust === "full" ? "danger-full-access" : o.sandbox === "workspace-write" ? "workspace-write" : "read-only";
+        return { cmd: "codex", args: ["exec", task, "--cd", o.cwd, ...(o.model ? ["-m", o.model] : []), "--sandbox", sb] };
+    }
+    return null;
+}
+const BUILTIN_BACKENDS = ["claude", "codex"];
+/** Probe a CLI's availability via `<bin> --version` (cached per process). */
+const availCache = new Map();
+function available(bin) {
+    if (availCache.has(bin))
+        return availCache.get(bin);
+    let ok = false;
+    try {
+        execFileSync(bin, ["--version"], { stdio: "ignore", timeout: 5000 });
+        ok = true;
+    }
+    catch {
+        ok = false;
+    }
+    availCache.set(bin, ok);
+    return ok;
+}
+function resolveTrust() {
+    const cfg = loadConfig();
+    const v = (process.env.HARA_EXTERNAL_AGENT_TRUST ?? cfg.externalAgentTrust ?? "gated");
+    return v === "off" || v === "full" ? v : "gated";
+}
+registerTool({
+    name: "external_agent",
+    description: "Delegate a self-contained coding task to an EXTERNAL agent CLI — `claude` (Claude Code) or `codex` — " +
+        "running headless in the current directory, and return its result. Use for heavy, isolated work you want " +
+        "another agent to own end-to-end. It can read/write/run on the host, so it's gated by approval. " +
+        "Args: task (required), backend (claude|codex; default = first installed), model (optional).",
+    kind: "exec", // → approval gate; never exposed to read-only fan-out sub-agents
+    input_schema: {
+        type: "object",
+        properties: {
+            task: { type: "string", description: "the self-contained task for the external agent" },
+            backend: { type: "string", description: "claude | codex (default: first available on PATH)" },
+            model: { type: "string", description: "optional model id override for the external agent" },
+            timeout_ms: { type: "number", description: "hard cap in ms (default 600000, max 1800000)" },
+        },
+        required: ["task"],
+    },
+    async run(input, ctx) {
+        const trust = resolveTrust();
+        if (trust === "off")
+            return "external_agent is disabled (set externalAgentTrust to gated|full, or HARA_EXTERNAL_AGENT_TRUST).";
+        const task = typeof input.task === "string" ? input.task.trim() : "";
+        if (!task)
+            return "external_agent needs a non-empty `task`.";
+        const installed = BUILTIN_BACKENDS.filter((b) => available(b));
+        const backend = String(input.backend ?? "").trim() || installed[0] || "";
+        if (!BUILTIN_BACKENDS.includes(backend))
+            return `Unknown backend '${backend || "(none)"}'. Supported: ${BUILTIN_BACKENDS.join(", ")}.`;
+        if (!available(backend))
+            return `'${backend}' CLI not found on PATH. Installed external agents: ${installed.join(", ") || "none"}.`;
+        const built = buildExternalArgv(backend, task, { cwd: ctx.cwd, model: input.model ? String(input.model) : undefined, sandbox: ctx.sandbox ?? "off", trust });
+        if (!built)
+            return `Unknown backend '${backend}'.`;
+        const timeout = Math.min(Math.max(30_000, Number(input.timeout_ms) || 600_000), 1_800_000);
+        return await new Promise((resolve) => {
+            const child = spawn(built.cmd, built.args, { cwd: ctx.cwd, env: process.env });
+            let out = "";
+            let err = "";
+            let done = false;
+            const finish = (s) => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                resolve(capHeadTail(s));
+            };
+            const timer = setTimeout(() => {
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    /* already gone */
+                }
+                finish(`[${backend}] timed out after ${timeout}ms\n${out}`);
+            }, timeout);
+            child.stdin.end(); // task is passed via argv
+            child.stdout.on("data", (d) => {
+                out += d.toString();
+                ctx.ui?.notice?.(d.toString().trimEnd());
+            });
+            child.stderr.on("data", (d) => {
+                err += d.toString();
+            });
+            child.on("error", (e) => finish(`[${backend}] failed to start: ${e.message} (is it installed?)`));
+            child.on("close", (code) => {
+                const text = out.trim() || "(external agent produced no output)";
+                finish(code === 0 ? text : `[${backend} exit ${code}]\n${text}${err ? `\n[stderr]\n${err.trim()}` : ""}`);
+            });
+        });
+    },
+});

package/dist/tools/skill.js

@@ -1,6 +1,7 @@
 // The `skill` tool — load a skill's full instructions on demand. The system prompt lists available
 // skills (id + description); the model calls this to pull the body before doing a task the skill covers.
 // Returning the body as a tool RESULT (not editing the system prompt) keeps the cached prefix stable.
+import { dirname } from "node:path";
 import { registerTool } from "./registry.js";
 import { loadSkillIndex, loadSkillBody } from "../skills/skills.js";
 import { scanMemory } from "../memory/guard.js";
@@ -21,10 +22,13 @@ registerTool({
         const scan = scanMemory(body); // skills may come from plugins (untrusted) — guard at load time
         if (!scan.ok)
             return `Skill '${id}' blocked: its content looks unsafe (${scan.hits.join(", ")}).`;
+        // Tell the model where this skill lives so it can read sibling files (assets/, references/) by absolute
+        // path — relying on "~" or cwd-relative guessing is unreliable across tools/sandboxes.
+        const located = `Skill directory (absolute): ${dirname(sk.file)}\nRead any sibling files this skill mentions (e.g. references/…, assets/…) from under that directory.\n\n${body}`;
         if (sk.context === "fork" && ctx.spawn) {
             // fork: run the skill as a delegated sub-agent rather than inlining it into this turn
-            return await ctx.spawn(`Follow this skill to complete the current task:\n\n${body}`);
+            return await ctx.spawn(`Follow this skill to complete the current task:\n\n${located}`);
         }
-        return body; // inline (default): the body enters the conversation as this tool's result
+        return located; // inline (default): the body enters the conversation as this tool's result
     },
 });

package/dist/tools/todo.js

@@ -7,6 +7,29 @@ let todos = [];
 export function currentTodos() {
     return todos;
 }
+const listeners = new Set();
+/** Subscribe to checklist changes. Returns an unsubscribe fn. */
+export function onTodosChange(fn) {
+    listeners.add(fn);
+    return () => {
+        listeners.delete(fn);
+    };
+}
+function emit() {
+    for (const fn of listeners) {
+        try {
+            fn(todos);
+        }
+        catch {
+            /* listeners must not break the tool */
+        }
+    }
+}
+/** Reset between sessions/turns if a runner wants a clean slate (not used by the tool itself). */
+export function clearTodos() {
+    todos = [];
+    emit();
+}
 const MARK = { pending: "☐", in_progress: "▶", done: "☑" };
 export function renderTodos(list) {
     if (!list.length)
@@ -16,9 +39,33 @@ export function renderTodos(list) {
 }
 registerTool({
     name: "todo_write",
-    description: "Maintain a short task checklist for the CURRENT work. Use it to plan a multi-step task up front, then " +
-        "update it as you go: keep exactly one item 'in_progress', flip items to 'done' as you finish, add items " +
-        "you discover. Pass the FULL list each call (it replaces the previous). Skip it for trivial one-step tasks.",
+    description: "Maintain a short task checklist for the CURRENT work. Pass the FULL list each call (it replaces the previous). " +
+        "Each item has `text` (imperative, e.g. 'Run tests') AND `activeForm` (present-continuous, e.g. 'Running tests') — " +
+        "the UI shows activeForm while the item is in_progress. Exactly ONE item should be in_progress at a time; flip " +
+        "items to 'done' as you finish; add items you discover. " +
+        "\n\n## Use this tool when" +
+        "\n  - the task takes 3+ distinct steps (refactor across files, new feature, multi-file fix, migrations)" +
+        "\n  - the user gave you a numbered/comma-separated list of things to do" +
+        "\n  - you discover mid-work that scope grew past a single edit" +
+        "\n  - the user explicitly asks for a plan/checklist" +
+        "\n\n## Skip this tool when" +
+        "\n  - reading one file or answering one question" +
+        "\n  - running one shell command and reporting output" +
+        "\n  - a single straight-line edit to one location" +
+        "\n  - pure conversation / explanation" +
+        "\n\n## Examples — use it" +
+        "\n  user: \"add a dark-mode toggle and run tests\" → 4-5 items (component, state, styles, tests)" +
+        "\n  user: \"rename getCwd to getCurrentWorkingDirectory across the project\" → one item per file after grepping" +
+        "\n  user: \"implement registration, catalog, cart, checkout\" → break each feature into 2-3 sub-items" +
+        "\n  user: \"optimize this slow React app\" → one item per identified bottleneck" +
+        "\n\n## Examples — skip it" +
+        "\n  user: \"how do I print 'hello' in python?\" → answer directly" +
+        "\n  user: \"what does git status do?\" → explain" +
+        "\n  user: \"add a comment to calculateTotal\" → one edit, no plan needed" +
+        "\n  user: \"run npm install\" → one exec, report output" +
+        "\n\n## After updating the list" +
+        "\nBriefly say what changed in one short line (e.g. \"marked 2 done, starting on tests\"); do NOT repeat the full " +
+        "checklist back to the user — the UI already renders it live.",
     input_schema: {
         type: "object",
         properties: {
@@ -28,7 +75,11 @@ registerTool({
                 items: {
                     type: "object",
                     properties: {
-                        text: { type: "string", description: "the task, a short imperative phrase" },
+                        text: { type: "string", description: "the task, a short imperative phrase (e.g. 'Run tests')" },
+                        activeForm: {
+                            type: "string",
+                            description: "present-continuous form shown while in_progress (e.g. 'Running tests'). Always provide.",
+                        },
                         status: { type: "string", enum: ["pending", "in_progress", "done"] },
                     },
                     required: ["text", "status"],
@@ -41,11 +92,17 @@ registerTool({
     async run(input) {
         const raw = Array.isArray(input.todos) ? input.todos : [];
         todos = raw
-            .map((t) => ({
-            text: String(t?.text ?? "").trim(),
-            status: (["pending", "in_progress", "done"].includes(t?.status) ? t.status : "pending"),
-        }))
+            .map((t) => {
+            const text = String(t?.text ?? "").trim();
+            const status = (["pending", "in_progress", "done"].includes(t?.status) ? t.status : "pending");
+            const activeFormRaw = typeof t?.activeForm === "string" ? t.activeForm.trim() : "";
+            const item = { text, status };
+            if (activeFormRaw)
+                item.activeForm = activeFormRaw;
+            return item;
+        })
             .filter((t) => t.text);
+        emit();
         return renderTodos(todos);
     },
 });