@nanhara/hara 0.123.0 → 0.124.0

package/dist/index.js

@@ -26,7 +26,7 @@ import { clearEnrollment, enrollDevice, heartbeat, syncOrgRoles } from "./org-fl
 import { loadActiveProfile, listProfiles, useProfile, addProfile, upsertProfile, removeProfile, setModel as setProfileModel, resetModel as resetProfileModel, getProfile, effectiveModel, routingLabel, routeHost, activeId, resolveActive, setFlagOverride, writePin, removePin, pinFilePath, DEFAULT_ORG_ID, PERSONAL_ID, } from "./profile/profile.js";
 import { loadPermissionRules, scaffoldPermissions, globalPermissionsPath, projectPermissionsPath } from "./security/permissions.js";
 import { routingProvider } from "./agent/route.js";
-import { shouldAutoCompact, shouldAutoCompactTokens, AUTO_COMPACT_TOKEN_CAP, COMPACT_SYSTEM, buildFileRestore, workingSetFromSummary } from "./agent/compact.js";
+import { shouldAutoCompact, shouldAutoCompactTokens, AUTO_COMPACT_TOKEN_CAP, COMPACT_SYSTEM, buildFileRestore, compactedConversationHistory, compactedHistoryTokenEstimate, compactionSourceHistory, normalizeCompactionSummary, recentHistoryForCompaction, workingSetFromSummary, } from "./agent/compact.js";
 import { recentTouched, clearTouched } from "./agent/touched.js";
 import { INTERJECT_PREFIX, disposeReminderScope } from "./agent/reminders.js";
 import { checkForUpdate } from "./update-check.js";
@@ -43,6 +43,7 @@ import { installScheduler, uninstallScheduler, isInstalled } from "./cron/instal
 import { getTools } from "./tools/registry.js";
 import { resetReachability } from "./tools/net-reachability.js";
 import { resetRepeatGuard } from "./agent/repeat-guard.js";
+import { allowsEvolutionTool, EVOLUTION_SYSTEM, evolutionStatus, shouldAutoEvolve } from "./agent/evolution.js";
 import { EXPLORE_SYSTEM } from "./tools/agent.js";
 import { createAnthropicProvider } from "./providers/anthropic.js";
 import { createOpenAIProvider } from "./providers/openai.js";
@@ -67,7 +68,7 @@ function renderBgJobs() {
     });
     return `Background jobs — /jobs tail <id> · /jobs kill <id>:\n${rows.join("\n")}`;
 }
-import { qwenDeviceLogin, getValidQwenAuth } from "./providers/qwen-oauth.js";
+import { qwenDeviceLogin, getValidQwenAuth, loadQwenToken } from "./providers/qwen-oauth.js";
 import { loadAgentContext, hasAgentsMd, INIT_PROMPT, findProjectRoot } from "./context/agents-md.js";
 import { homeWorkspaceActionError, isHomeWorkspace } from "./context/workspace-scope.js";
 import { getEmbedder } from "./search/embed.js";
@@ -75,7 +76,7 @@ import { collectRepoChunksAsync, collectDirChunksAsync, buildIndex, indexPath, i
 import { searchHybrid } from "./search/hybrid.js";
 import { expandMentionsAsync, fileCandidates, isSlashCommand, inlineLeadingPath } from "./context/mentions.js";
 import { newSessionId, shortId, resolveSessionId, validSessionId, sessionFileExists, saveSession, loadSession, acquireSessionLock, releaseSessionLock, listSessions, latestForCwd, titleFrom, sessionSourceFromEnv, automatedTitle, slugify, } from "./session/store.js";
-import { continueTaskExecution, createTaskExecution, finishTaskExecution, formatTaskExecution, newSteerInteraction, newTurnInteraction, recordTaskSteering, recoverTaskExecution, taskExecutionContext, } from "./session/task.js";
+import { consumePendingTaskSteering, continueTaskExecution, createTaskExecution, finishTaskExecution, formatTaskExecution, hasPendingTaskSteering, newSteerInteraction, newTurnInteraction, recordTaskSteering, recoverTaskExecution, requestsTaskContinuation, taskExecutionContext, } from "./session/task.js";
 import { setSessionForceModel, isSessionForceModel, effectiveRoleModel } from "./session/session-model.js";
 import { loadGlobalRoles, loadRoles, roleToolFilter, scaffoldRoles, subagentToolFilter } from "./org/roles.js";
 import { buildAgentsIndex, canonicalProjectPath, resolveAgent, loadProjects, addProject, removeProject } from "./org/projects.js";
@@ -860,31 +861,51 @@ const PLAN_SYSTEM = "You are in PLAN MODE — a read-only investigation phase. E
     "When (and only when) you have a complete, actionable plan, call the `exit_plan` tool with the full plan " +
     "(concise markdown, short numbered steps), then stop and wait for the user's decision. " +
     "If the user is asking a question, or the plan isn't ready yet, just answer normally WITHOUT calling exit_plan.";
-const DISTILL_SYSTEM = "The session is ending. Reflect and persist only durable, reusable learnings: memory_write for facts / " +
-    "conventions / the user's preferences, skill_create for reusable how-tos. Be selective — skip the trivial. Then reply DONE.";
 const MEMORY_DISTILL_SYSTEM = "You consolidate an agent's short-term daily memory logs into its durable long-term memory. You're given " +
     "the current durable memory and recent daily logs. Extract ONLY durable, reusable facts / decisions / " +
     "conventions / user preferences from the logs that are NOT already captured, and persist each with " +
     "memory_write (target=memory, or target=user for preferences; pick the right scope=project|global). " +
     "Skip the ephemeral, the one-off, and anything already known. Be terse and de-duplicated. Then reply DONE.";
-// COMPACT_SYSTEM (the 8-section brief) + workingSetFromSummary live in agent/compact.ts so tests can
-// pin their structure and serve's session.compact shares the exact same distillation.
+async function curateSessionLearning(provider, history, cfg, options) {
+    // Curation gets a private transcript branch: its DONE/tool chatter must not become task conversation or
+    // create assistant→assistant role adjacency. Memory/skill writes remain the only durable side effects.
+    const curationHistory = [
+        ...history,
+        { role: "user", content: "Run the evidence-gated self-evolution curation now. If nothing qualifies, write nothing." },
+    ];
+    return runAgent(curationHistory, {
+        provider,
+        ctx: { cwd: options.cwd, sandbox: options.sandbox, spawn: options.spawn, ui: options.ui },
+        approval: cfg.assetCapture === "auto" ? "full-auto" : "suggest",
+        confirm: options.confirm,
+        toolFilter: (name) => allowsEvolutionTool(name, cfg.assetCapture),
+        systemOverride: EVOLUTION_SYSTEM,
+        memory: options.memory,
+        stats: options.stats,
+        signal: options.signal,
+        ...agentRunLimits(cfg),
+    });
+}
+// The bounded checkpoint contract + recent-turn preservation live in agent/compact.ts so CLI and serve
+// cannot drift into different context semantics.
 /** Summarize the conversation and replace history with the summary (keeping working-memory notes). Shared by
  *  /compact (manual) and auto-compaction. Returns the summary, or null on failure / nothing to do. */
 async function compactConversation(provider, history, meta, stats, signal, task) {
     if (history.length < 2 || signal?.aborted)
         return null;
+    const recent = recentHistoryForCompaction(history);
     const r = await boundedProviderTurn(provider, {
         system: COMPACT_SYSTEM,
-        history: [...history, { role: "user", content: "Summarize our conversation so far per the instructions." }],
+        history: [...compactionSourceHistory(history), { role: "user", content: "Create the bounded execution checkpoint now." }],
         tools: [],
         onText: () => { },
     }, { timeoutMs: 60_000, label: "conversation compaction", signal });
     if (signal?.aborted || r.stop === "error")
         return null;
-    const summary = r.text.trim();
-    if (!summary)
+    const rawSummary = r.text.trim();
+    if (!rawSummary)
         return null;
+    const summary = normalizeCompactionSummary(rawSummary);
     const workingSet = workingSetFromSummary(summary);
     // TW5-style file restore: the summary alone loses the working set's ACTUAL content — re-attach the
     // most recently touched files (current on-disk state, byte-capped) so work continues without re-reads.
@@ -902,13 +923,12 @@ async function compactConversation(provider, history, meta, stats, signal, task)
     if (signal?.aborted)
         return null;
     meta.workingSet = workingSet; // survives the history wipe + injects into the next turns
+    const compacted = compactedConversationHistory(summary, recent, restore);
     history.length = 0;
-    history.push({ role: "user", content: `Summary of our conversation so far (continue from here):\n\n${summary}` });
-    if (restore)
-        history.push({ role: "user", content: restore });
+    history.push(...compacted);
     stats.input += r.usage?.input ?? 0;
     stats.output += r.usage?.output ?? 0;
-    stats.lastInput = r.usage?.input ?? 0; // ctx% now reflects the (small) summary, not the old full turn
+    stats.lastInput = compactedHistoryTokenEstimate(compacted); // reflect replacement, not the large summarizer request
     saveSession(meta, history, task);
     return summary;
 }
@@ -1023,7 +1043,7 @@ function runDoctor(cfg) {
     const dot = c.dim("·");
     const nodeSupported = unsupportedNodeMessage() === null;
     const hasKey = !!(cfg.apiKey || process.env[providerEnvKey(cfg.provider)] || process.env.HARA_API_KEY);
-    const oauthOk = cfg.provider === "qwen-oauth" && existsSync(join(homedir(), ".hara", "qwen-oauth.json"));
+    const oauthOk = cfg.provider === "qwen-oauth" && loadQwenToken() !== null;
     const authed = hasKey || oauthOk;
     const ad = assetsDir();
     const roles = loadRoles(cfg.cwd);
@@ -2006,14 +2026,8 @@ program
                 return void out(c.yellow(`↩ ${pane} registered, but no WeChat login (run \`hara gateway --platform weixin --login\`). Your next reply to the bot still injects here.\n`));
             let peer = process.env.HARA_WX_PEER;
             if (!peer) {
-                try {
-                    const f = join(homedir(), ".hara", "weixin", `${creds.account_id}.context-tokens.json`);
-                    const keys = Object.keys(JSON.parse(readFileSync(f, "utf8")));
-                    peer = keys.find((k) => k.endsWith("@im.wechat")) || keys[0];
-                }
-                catch {
-                    /* no peer file */
-                }
+                const peers = wx.weixinKnownPeers(creds.account_id);
+                peer = peers.find((candidate) => candidate.endsWith("@im.wechat")) || peers[0];
             }
             if (peer)
                 await wx.weixinAdapter(creds).send(peer, text);
@@ -2416,7 +2430,7 @@ memoryCmd
         ctx: { cwd: cfg.cwd, sandbox: cfg.sandbox },
         approval: "full-auto",
         confirm: async () => true,
-        toolFilter: (n) => n === "memory_write" || READONLY_TOOLS.has(n),
+        toolFilter: (n) => allowsEvolutionTool(n, "off"),
         systemOverride: MEMORY_DISTILL_SYSTEM,
         stats,
         ...agentRunLimits(cfg),
@@ -3061,6 +3075,16 @@ program.action(async (opts) => {
                 }
                 schemaObj = parsed;
             }
+            // Recover any steering that was acknowledged by serve before a crash but had not yet reached a model
+            // round. The next session write commits its transcript copy and consumed marker atomically.
+            const recoveredHeadlessSteering = consumePendingTaskSteering(task);
+            if (recoveredHeadlessSteering) {
+                task = recoveredHeadlessSteering.task;
+                history.push(...recoveredHeadlessSteering.entries.map((entry) => ({
+                    role: "user",
+                    content: `${INTERJECT_PREFIX}\n\n${entry.content}`,
+                })));
+            }
             // Inbound images (gateway): the platform downloaded the user's photo(s) and passed their paths via env.
             // Let the agent actually SEE them — attached inline for a vision-capable main model, else described via the
             // visionModel sidecar and folded into the message (text-only models can't take image blocks).
@@ -3095,7 +3119,8 @@ program.action(async (opts) => {
             // A resumed unfinished task keeps its objective; this prompt is a new turn that steers it. A completed
             // task (or a stateless -p run) starts a fresh execution identity. Persist before provider side effects so
             // a crash is recoverable as paused rather than looking like a completed turn.
-            const headlessInteraction = task && task.status !== "completed"
+            const headlessInteraction = task && task.status !== "completed" &&
+                (recoveredHeadlessSteering !== null || requestsTaskContinuation(String(opts.print)))
                 ? newSteerInteraction(task.turnId)
                 : newTurnInteraction();
             if (headlessInteraction.kind === "steer") {
@@ -3104,6 +3129,9 @@ program.action(async (opts) => {
             }
             else {
                 task = createTaskExecution(String(opts.print), headlessInteraction.turnId);
+                clearTodos();
+                if (meta)
+                    meta.todos = [];
             }
             if (meta)
                 saveSession(meta, history, task);
@@ -3141,7 +3169,7 @@ program.action(async (opts) => {
                 projectContext,
                 memory: memoryDigest(cwd),
                 continuationSession,
-                executionContext: taskExecutionContext(task, headlessInteraction),
+                executionContext: taskExecutionContext(task, headlessInteraction, meta?.todos ?? []),
                 ...(roleOverride ? { systemOverride: roleOverride } : {}),
                 ...(headlessToolFilter ? { toolFilter: headlessToolFilter } : {}),
                 hooks: headlessHooks,
@@ -3432,6 +3460,14 @@ program.action(async (opts) => {
     };
     const commands = [
         { name: "help", desc: "show this help", run: () => void out(helpText(commands)) },
+        {
+            name: "continue",
+            aliases: ["resume"],
+            desc: "resume the unfinished task: /continue [instruction]",
+            // Interactive loops translate this command into an ordinary model turn before slash dispatch. This
+            // fallback only protects future callers that invoke the command table directly.
+            run: () => void out(c.dim("(type /continue [instruction] in an interactive session)\n")),
+        },
         {
             name: "init",
             desc: "analyze project & regenerate AGENTS.md",
@@ -3632,6 +3668,18 @@ program.action(async (opts) => {
                 out(formatTaskExecution(task) + "\n");
             },
         },
+        {
+            name: "new",
+            desc: "start a new task while keeping conversation context",
+            run: () => {
+                task = undefined;
+                resumeTaskPending = false;
+                clearTodos();
+                meta.todos = [];
+                persistSession();
+                out(c.dim("(new task boundary; conversation kept — type the new objective)\n"));
+            },
+        },
         {
             name: "rewind",
             desc: "fork the conversation back to an earlier turn: /rewind (list) · /rewind <n> (files unchanged)",
@@ -3668,6 +3716,32 @@ program.action(async (opts) => {
                 out(k == null ? c.red("(restore failed)\n") : c.green(`(restored ${k} file(s) to ${cp.sha} — '${cp.label}'; prior state snapshotted too)\n`));
             },
         },
+        {
+            name: "evolve",
+            desc: "show or run auditable self-evolution: /evolve [status|now]",
+            run: async (a) => {
+                const action = (a ?? "").trim() || "status";
+                if (action === "status")
+                    return void out(evolutionStatus(cfg) + "\n");
+                if (action !== "now")
+                    return void out(c.dim("usage: /evolve [status|now]\n"));
+                if (cfg.evolve === "off")
+                    return void out(c.dim("(self-evolution is off — set `hara config set evolve light|proactive` first)\n"));
+                if (history.length < 2)
+                    return void out(c.dim("(not enough session evidence to curate)\n"));
+                out(c.dim("Curating evidence-backed memories and reusable skills…\n"));
+                const outcome = await curateSessionLearning(provider, history, cfg, {
+                    cwd,
+                    sandbox,
+                    spawn,
+                    confirm,
+                    memory: buildMemory(),
+                    stats,
+                });
+                persistSession();
+                out(outcome.status === "completed" ? c.green("(self-evolution curation complete)\n") : c.yellow(`(self-evolution stopped: ${outcome.error ?? outcome.status})\n`));
+            },
+        },
         {
             name: "compact",
             desc: "summarize the conversation so far to free up context",
@@ -3677,6 +3751,21 @@ program.action(async (opts) => {
                 currentTurn = compactTurn;
                 let summary = null;
                 try {
+                    if (cfg.evolve !== "off") {
+                        const distill = await curateSessionLearning(provider, history, cfg, {
+                            cwd,
+                            sandbox,
+                            spawn,
+                            confirm,
+                            memory: buildMemory(),
+                            stats,
+                            signal: compactTurn.signal,
+                        });
+                        if (distill.status !== "completed") {
+                            out(c.yellow(`(compact cancelled — self-evolution stopped: ${distill.error ?? distill.status})\n`));
+                            return;
+                        }
+                    }
                     summary = await compactConversation(provider, history, meta, stats, compactTurn.signal, task);
                 }
                 finally {
@@ -3731,7 +3820,24 @@ program.action(async (opts) => {
                 out(c.dim("(context cleared)\n"));
             },
         },
-        { name: "exit", aliases: ["quit"], desc: "leave", run: () => "exit" },
+        {
+            name: "exit",
+            aliases: ["quit"],
+            desc: "leave",
+            run: async () => {
+                if (shouldAutoEvolve(cfg.evolve, history.length)) {
+                    out(c.dim("Distilling session learnings…\n"));
+                    try {
+                        await curateSessionLearning(provider, history, cfg, { cwd, sandbox, spawn, confirm, memory: buildMemory(), stats });
+                        persistSession();
+                    }
+                    catch {
+                        /* exiting remains available if optional curation fails */
+                    }
+                }
+                return "exit";
+            },
+        },
     ];
     const byName = new Map();
     for (const cmd of commands) {
@@ -3896,26 +4002,37 @@ program.action(async (opts) => {
             onClipboardImage: readClipboardImage,
             vim: cfg.vimMode,
             onSubmit: async (line, h, images, interaction) => {
+                // `/continue` is a task interaction, not a control-only command: turn it into a model message before
+                // slash dispatch, preserving the submitted turn id while explicitly targeting the unfinished task.
+                const continueCommand = /^\/(?:continue|resume)(?:\s+([\s\S]+))?$/i.exec(line.trim());
+                if (continueCommand) {
+                    if (!task || task.status === "completed")
+                        return void h.sink.notice("(there is no unfinished task to continue)");
+                    line = continueCommand[1]?.trim() || "continue";
+                    interaction = {
+                        kind: "steer",
+                        expectedTurnId: task.turnId,
+                        turnId: interaction?.turnId ?? newTurnInteraction().turnId,
+                    };
+                }
                 // A dropped/pasted file path (`/Users/…/doc.md`, maybe trailing text/images) starts with '/' but
                 // is NOT a command — treat it as a file to read, not "Unknown command" (see isSlashCommand).
                 if (isSlashCommand(line)) {
                     const [nm, ...rest] = line.slice(1).split(/\s+/);
                     const arg = rest.join(" ").trim();
                     if (nm === "exit" || nm === "quit") {
-                        if (cfg.evolve === "proactive" && history.length >= 4) {
+                        if (shouldAutoEvolve(cfg.evolve, history.length)) {
                             h.sink.notice("✻ distilling session learnings…");
                             try {
-                                await runAgent(history, {
-                                    provider,
-                                    ctx: { cwd, sandbox, spawn, ui: { text: h.sink.assistantDelta, reasoning: h.sink.reasoningDelta, tool: h.sink.tool, diff: h.sink.diff, notice: h.sink.notice } },
-                                    approval: cfg.assetCapture === "auto" ? "full-auto" : "suggest", // ask → prompt before each save; auto → silent
+                                await curateSessionLearning(provider, history, cfg, {
+                                    cwd,
+                                    sandbox,
+                                    spawn,
+                                    ui: { text: h.sink.assistantDelta, reasoning: h.sink.reasoningDelta, tool: h.sink.tool, diff: h.sink.diff, notice: h.sink.notice },
                                     confirm: h.confirm,
-                                    toolFilter: (n) => n === "memory_write" || (cfg.assetCapture !== "off" && n === "skill_create") || READONLY_TOOLS.has(n),
-                                    systemOverride: DISTILL_SYSTEM,
                                     memory: buildMemory(),
                                     stats,
                                     signal: h.signal,
-                                    ...agentRunLimits(cfg),
                                 });
                                 persistSession();
                             }
@@ -3929,6 +4046,29 @@ program.action(async (opts) => {
                         return void h.sink.notice(commands.map((x) => `/${x.name} — ${x.desc}`).join("\n"));
                     if (nm === "tools")
                         return void h.sink.notice(getTools().map((t) => `${t.name}${t.kind !== "read" ? " *" : ""} — ${t.description}`).join("\n"));
+                    if (nm === "evolve") {
+                        if (!arg || arg === "status")
+                            return void h.sink.notice(evolutionStatus(cfg));
+                        if (arg !== "now")
+                            return void h.sink.notice("usage: /evolve [status|now]");
+                        if (cfg.evolve === "off")
+                            return void h.sink.notice("(self-evolution is off — set `hara config set evolve light|proactive` first)");
+                        if (history.length < 2)
+                            return void h.sink.notice("(not enough session evidence to curate)");
+                        h.sink.notice("✻ curating evidence-backed memories and reusable skills…");
+                        const outcome = await curateSessionLearning(provider, history, cfg, {
+                            cwd,
+                            sandbox,
+                            spawn,
+                            ui: { text: h.sink.assistantDelta, reasoning: h.sink.reasoningDelta, tool: h.sink.tool, diff: h.sink.diff, notice: h.sink.notice },
+                            confirm: h.confirm,
+                            memory: buildMemory(),
+                            stats,
+                            signal: h.signal,
+                        });
+                        persistSession();
+                        return void h.sink.notice(outcome.status === "completed" ? "(self-evolution curation complete)" : `(self-evolution stopped: ${outcome.error ?? outcome.status})`);
+                    }
                     if (nm === "reset" || nm === "clear") {
                         history.length = 0;
                         task = undefined;
@@ -4016,6 +4156,14 @@ program.action(async (opts) => {
                         }
                         return void h.sink.notice(formatTaskExecution(task));
                     }
+                    if (nm === "new") {
+                        task = undefined;
+                        resumeTaskPending = false;
+                        clearTodos();
+                        meta.todos = [];
+                        persistSession();
+                        return void h.sink.notice("(new task boundary; conversation kept — type the new objective)");
+                    }
                     if (nm === "rewind") {
                         if (!arg) {
                             const turns = userTurnPreviews(history);
@@ -4051,17 +4199,15 @@ program.action(async (opts) => {
                         let distillOutcome;
                         if (cfg.evolve !== "off") {
                             try {
-                                distillOutcome = await runAgent(history, {
-                                    provider,
-                                    ctx: { cwd, sandbox, spawn, ui: cui },
-                                    approval: cfg.assetCapture === "auto" ? "full-auto" : "suggest", // ask → prompt before each save; auto → silent
+                                distillOutcome = await curateSessionLearning(provider, history, cfg, {
+                                    cwd,
+                                    sandbox,
+                                    spawn,
+                                    ui: cui,
                                     confirm: h.confirm,
-                                    toolFilter: (n) => n === "memory_write" || (cfg.assetCapture !== "off" && n === "skill_create") || READONLY_TOOLS.has(n),
-                                    systemOverride: DISTILL_SYSTEM,
                                     memory: buildMemory(),
                                     stats,
                                     signal: h.signal,
-                                    ...agentRunLimits(cfg),
                                 });
                             }
                             catch {
@@ -4171,6 +4317,8 @@ program.action(async (opts) => {
                         if (sk) {
                             h.sink.notice(`↗ entering ${sk.id}…`);
                             resumeTaskPending = false; // an explicit skill entry starts its own task
+                            clearTodos();
+                            meta.todos = [];
                             const skillContent = `Skill \`${sk.id}\`:\n${loadSkillBody(sk)}\n\n---\nEntering ${sk.id} mode${arg ? ` — request: ${arg}` : ""}. Follow this skill now. If it has a workspace or live preview, OPEN it FIRST so any existing progress is visible, then proceed — offer to continue existing work or start fresh.`;
                             const skillInteraction = interaction ?? newTurnInteraction();
                             if (skillInteraction.kind === "steer") {
@@ -4218,7 +4366,8 @@ program.action(async (opts) => {
                 const ui = { text: h.sink.assistantDelta, reasoning: h.sink.reasoningDelta, tool: h.sink.tool, diff: h.sink.diff, notice: h.sink.notice };
                 const appr = h.approval;
                 let submittedInteraction = interaction ?? newTurnInteraction();
-                if (resumeTaskPending && task && submittedInteraction.kind === "turn") {
+                if (resumeTaskPending && task && submittedInteraction.kind === "turn" &&
+                    (hasPendingTaskSteering(task) || requestsTaskContinuation(line))) {
                     submittedInteraction = { kind: "steer", expectedTurnId: task.turnId, turnId: submittedInteraction.turnId };
                 }
                 const beginExecution = (objective) => {
@@ -4232,15 +4381,17 @@ program.action(async (opts) => {
                     }
                     else {
                         task = createTaskExecution(objective, submittedInteraction.turnId);
+                        clearTodos();
+                        meta.todos = [];
                     }
                     resumeTaskPending = false;
-                    return taskExecutionContext(task, submittedInteraction);
+                    return taskExecutionContext(task, submittedInteraction, meta.todos ?? []);
                 };
                 // Type-ahead steering: fold messages typed mid-turn into the next model call (codex-style) so a
                 // clarification/addition course-corrects the live task, rather than waiting for a fresh turn.
                 // Shared by every turn below (plan investigate, plan execute, and the regular turn).
                 const pendingInput = async () => {
-                    const out = [];
+                    const freshMessages = new Map();
                     for (const it of h.drainQueue()) {
                         const r2 = await resolveImages(it.images, h);
                         const body = await expandMentionsAsync(it.line, cwd, { signal: h.signal }) + (r2.skip ? "" : (r2.extraText ?? ""));
@@ -4253,13 +4404,25 @@ program.action(async (opts) => {
                             continue;
                         }
                         task = recorded.task;
-                        out.push({ role: "user", content: `${INTERJECT_PREFIX}\n\n${body}`, ...(attach ? { images: attach } : {}) });
+                        const accepted = task.steering?.at(-1);
+                        if (accepted?.deliveryState === "pending") {
+                            freshMessages.set(accepted.id, { role: "user", content: `${INTERJECT_PREFIX}\n\n${body}`, ...(attach ? { images: attach } : {}) });
+                        }
                     }
-                    // runAgent appends these immediately after return. Persist an equivalent snapshot first so an
-                    // abrupt process exit cannot lose accepted steering while retaining a running task identity.
-                    if (out.length)
-                        saveSession(meta, [...history, ...out], task);
-                    return out;
+                    const consumed = consumePendingTaskSteering(task);
+                    if (!consumed)
+                        return [];
+                    const out = consumed.entries.map((entry) => freshMessages.get(entry.id) ?? ({
+                        role: "user",
+                        content: `${INTERJECT_PREFIX}\n\n${entry.content}`,
+                    }));
+                    // Persist the projected transcript and consumed inbox state first, then update the same live
+                    // history synchronously. Returning [] prevents runAgent from appending the messages twice;
+                    // loop from appending twice; cancellation/error saves can no longer overwrite the projected input.
+                    saveSession(meta, [...history, ...out], consumed.task);
+                    task = consumed.task;
+                    history.push(...out);
+                    return [];
                 };
                 const turnStart = Date.now(); // for the task-done notification (gated on elapsed)
                 if (appr === "plan") {
@@ -4459,6 +4622,16 @@ program.action(async (opts) => {
         bar.renderBottom(); // bottom border + modes/usage
         if (!line)
             continue;
+        let forcedContinuation;
+        const continueCommand = /^\/(?:continue|resume)(?:\s+([\s\S]+))?$/i.exec(line);
+        if (continueCommand) {
+            if (!task || task.status === "completed") {
+                out(c.dim("(there is no unfinished task to continue)\n"));
+                continue;
+            }
+            line = continueCommand[1]?.trim() || "continue";
+            forcedContinuation = newSteerInteraction(task.turnId);
+        }
         // A dropped/pasted file path starts with '/' but isn't a command — read it, don't error (see TUI path).
         if (isSlashCommand(line)) {
             const [name, ...rest] = line.slice(1).split(/\s+/);
@@ -4472,6 +4645,8 @@ program.action(async (opts) => {
                     const skillContent = `Skill \`${sk.id}\`:\n${loadSkillBody(sk)}\n\n---\nEntering ${sk.id} mode${rest.length ? ` — request: ${rest.join(" ")}` : ""}. Follow this skill now. If it has a workspace or live preview, OPEN it FIRST so any existing progress is visible, then proceed — offer to continue existing work or start fresh.`;
                     const skillInteraction = newTurnInteraction();
                     resumeTaskPending = false;
+                    clearTodos();
+                    meta.todos = [];
                     task = createTaskExecution(rest.join(" ") || `enter ${sk.id}`, skillInteraction.turnId);
                     const skillExecutionContext = taskExecutionContext(task, skillInteraction);
                     history.push({ role: "user", content: skillContent });
@@ -4512,9 +4687,18 @@ program.action(async (opts) => {
         line = inlineLeadingPath(line, existsSync); // leading dropped file path → @-mention so it's read in
         const userContent = (recalledContext ? `${recalledContext}\n\n---\n\n` : "") + await expandMentionsAsync(line, cwd);
         recalledContext = "";
-        let interaction = newTurnInteraction();
-        if (resumeTaskPending && task)
+        const recoveredClassicSteering = consumePendingTaskSteering(task);
+        if (recoveredClassicSteering) {
+            task = recoveredClassicSteering.task;
+            history.push(...recoveredClassicSteering.entries.map((entry) => ({
+                role: "user",
+                content: `${INTERJECT_PREFIX}\n\n${entry.content}`,
+            })));
+        }
+        let interaction = forcedContinuation ?? newTurnInteraction();
+        if (resumeTaskPending && task && (recoveredClassicSteering !== null || requestsTaskContinuation(line))) {
             interaction = newSteerInteraction(task.turnId);
+        }
         if (interaction.kind === "steer") {
             const continued = continueTaskExecution(task, interaction);
             if (!continued.ok) {
@@ -4525,9 +4709,11 @@ program.action(async (opts) => {
         }
         else {
             task = createTaskExecution(line, interaction.turnId);
+            clearTodos();
+            meta.todos = [];
         }
         resumeTaskPending = false;
-        const executionContext = taskExecutionContext(task, interaction);
+        const executionContext = taskExecutionContext(task, interaction, meta.todos ?? []);
         history.push({ role: "user", content: userContent });
         persistSession();
         if (cfg.fileCheckpoints)

package/dist/org-fleet/enroll.js

@@ -11,10 +11,10 @@
 //   POST {gateway}/v1/chat/completions  (OpenAI-compatible; the normal agent traffic, Bearer <device_token>)
 import { homedir, hostname, platform } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, rmSync } from "node:fs";
+import { writeFileSync, mkdirSync, rmSync } from "node:fs";
 import { orgRolesDir } from "../org/roles.js";
 import { loadActiveProfile } from "../profile/profile.js";
-const orgPath = () => join(homedir(), ".hara", "org.json");
+import { bindPrivateHaraStateFile, readPrivateStateFileSnapshotSync, removePrivateStateFile, writePrivateStateFileSync, } from "../security/private-state.js";
 const deviceInfo = () => ({ name: hostname(), os: platform(), hara_version: process.env.HARA_BUILD_VERSION ?? "dev" });
 /** The effective OpenAI-compatible base URL for an enrollment (explicit, else <gatewayUrl>/v1). */
 export function gatewayBaseURL(e) {
@@ -24,16 +24,15 @@ export function loadEnrollment() {
     // 1) Legacy storage (~/.hara/org.json) for back-compat with pre-profile builds. After the
     //    profile migration runs (lazily on any profile.ts read), org.json is renamed to .legacy
     //    so this branch only fires for users who never touched the new profile layer yet.
-    const p = orgPath();
-    if (existsSync(p)) {
-        try {
-            const e = JSON.parse(readFileSync(p, "utf8"));
-            if (e && typeof e === "object" && e.gatewayUrl && e.deviceToken)
-                return e;
-        }
-        catch {
-            /* fall through to profile-derived */
-        }
+    try {
+        const binding = bindPrivateHaraStateFile(homedir(), [], "org.json");
+        const snapshot = readPrivateStateFileSnapshotSync(binding.path, 1024 * 1024);
+        const e = snapshot ? JSON.parse(snapshot.text) : null;
+        if (e && typeof e === "object" && e.gatewayUrl && e.deviceToken)
+            return e;
+    }
+    catch {
+        /* fall through to profile-derived */
     }
     // 2) Active-profile path. profile.ts doesn't import enroll.ts so this static import is safe.
     try {
@@ -55,19 +54,15 @@ export function loadEnrollment() {
     return null;
 }
 function saveEnrollment(e) {
-    mkdirSync(join(homedir(), ".hara"), { recursive: true });
-    writeFileSync(orgPath(), JSON.stringify(e, null, 2) + "\n", { encoding: "utf8", mode: 0o600 }); // holds a device token → 0600
-    try {
-        chmodSync(orgPath(), 0o600);
-    }
-    catch {
-        /* best-effort */
-    }
+    const binding = bindPrivateHaraStateFile(homedir(), [], "org.json");
+    writePrivateStateFileSync(binding, JSON.stringify(e, null, 2) + "\n");
 }
 export function clearEnrollment() {
-    if (!existsSync(orgPath()))
+    const binding = bindPrivateHaraStateFile(homedir(), [], "org.json");
+    const snapshot = readPrivateStateFileSnapshotSync(binding.path, 1024 * 1024);
+    if (!snapshot)
         return false;
-    rmSync(orgPath());
+    removePrivateStateFile(binding.path, snapshot, binding.directory);
     return true;
 }
 /** Parse a control-plane enroll response (tolerant of snake_case / camelCase) into an Enrollment. */

package/dist/plugins/plugins.js

@@ -2,11 +2,11 @@
 // runtime. The existing loaders pick the contents up (skillsDirs/loadRoles append the resolvers below;
 // index.ts merges pluginMcpServers into the MCP set). Manifest is Claude-Code-compatible: we read
 // .claude-plugin/plugin.json, .hara-plugin/plugin.json, or a bare plugin.json at the plugin root.
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, rmSync, cpSync, symlinkSync, chmodSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync, cpSync, symlinkSync, chmodSync } from "node:fs";
 import { join, resolve, isAbsolute } from "node:path";
 import { homedir } from "node:os";
 import { execFileSync } from "node:child_process";
-import { readRawConfig } from "../config.js";
+import { readRawConfig, updateRawConfig } from "../config.js";
 export function pluginsDir() {
     return join(homedir(), ".hara", "plugins");
 }
@@ -193,11 +193,9 @@ export function panelsForProject(cwd) {
 }
 /** Persist a plugin's enabled flag in ~/.hara/config.json (`plugins.enabled[name]`). */
 export function setPluginEnabled(name, on) {
-    const p = join(homedir(), ".hara", "config.json");
-    const cfg = readRawConfig();
-    const plugins = (cfg.plugins && typeof cfg.plugins === "object" ? cfg.plugins : {});
-    plugins.enabled = { ...(plugins.enabled ?? {}), [name]: on };
-    cfg.plugins = plugins;
-    mkdirSync(join(homedir(), ".hara"), { recursive: true });
-    writeFileSync(p, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+    updateRawConfig((config) => {
+        const plugins = (config.plugins && typeof config.plugins === "object" ? config.plugins : {});
+        plugins.enabled = { ...(plugins.enabled ?? {}), [name]: on };
+        config.plugins = plugins;
+    });
 }