@nanhara/hara 0.123.1 → 0.124.1

package/dist/serve/server.js

@@ -10,7 +10,7 @@ import { homedir } from "node:os";
 import { isAbsolute, join, relative, sep } from "node:path";
 import "../tools/all.js"; // register the full built-in toolset — serve must work as a standalone entry
 import { runAgent } from "../agent/loop.js";
-import { COMPACT_SYSTEM, buildFileRestore, workingSetFromSummary } from "../agent/compact.js";
+import { COMPACT_SYSTEM, buildFileRestore, compactedConversationHistory, compactedHistoryTokenEstimate, compactionSourceHistory, normalizeCompactionSummary, recentHistoryForCompaction, workingSetFromSummary, } from "../agent/compact.js";
 import { rewindTo } from "../agent/rewind.js";
 import { analyzeContext } from "../agent/context-report.js";
 import { clearTouched, recentTouched } from "../agent/touched.js";
@@ -32,7 +32,9 @@ import { INTERJECT_PREFIX, disposeReminderScope } from "../agent/reminders.js";
 import { SessionHub, realStore } from "./sessions.js";
 import { parseFrame, rpcResult, rpcError, rpcNotify, ERR, PROTOCOL_VERSION } from "./protocol.js";
 import { readModelContextFileSync } from "../fs-read.js";
-import { createTaskExecution, continueTaskExecution, finishTaskExecution, newSteerInteraction, newTurnInteraction, recordTaskSteering, taskExecutionContext, } from "../session/task.js";
+import { optionalPosixOpenFlag } from "../fs-open-flags.js";
+import { sameOpenedFileIdentity } from "../fs-identity.js";
+import { consumePendingTaskSteering, createTaskExecution, continueTaskExecution, finishTaskExecution, newSteerInteraction, newTurnInteraction, recordTaskSteering, requestsTaskContinuation, taskExecutionContext, } from "../session/task.js";
 const APPROVAL_TIMEOUT_MS = 300_000; // an unanswered approval denies after 5 min (never hangs a turn)
 const COMPACT_TIMEOUT_MS = 60_000;
 const SHUTDOWN_GRACE_MS = 2_000;
@@ -54,7 +56,7 @@ const ensurePrivateDiscoveryDir = (dir) => {
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     let fd;
     try {
-        fd = openSync(dir, fsConstants.O_RDONLY | fsConstants.O_DIRECTORY | fsConstants.O_NOFOLLOW);
+        fd = openSync(dir, fsConstants.O_RDONLY | optionalPosixOpenFlag("O_DIRECTORY") | optionalPosixOpenFlag("O_NOFOLLOW"));
         const st = fstatSync(fd);
         if (!st.isDirectory())
             throw new Error(`${dir} must be a private directory, not a symlink`);
@@ -151,7 +153,7 @@ const writeDiscovery = async (dir, path, record) => {
         const temp = join(dir, `.serve.json.${process.pid}.${record.instanceId}.tmp`);
         let fd;
         try {
-            fd = openSync(temp, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY | fsConstants.O_NOFOLLOW, 0o600);
+            fd = openSync(temp, "wx", 0o600);
             fchmodSync(fd, 0o600);
             writeFileSync(fd, `${JSON.stringify(record, null, 2)}\n`, "utf8");
             fsyncSync(fd);
@@ -177,7 +179,7 @@ const removeOwnedDiscovery = async (dir, path, record) => {
     await withDiscoveryLock(dir, record.instanceId, () => {
         let fd;
         try {
-            fd = openSync(path, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+            fd = openSync(path, fsConstants.O_RDONLY | optionalPosixOpenFlag("O_NOFOLLOW"));
             const opened = fstatSync(fd);
             if (!opened.isFile() || opened.size > 64 * 1024)
                 return;
@@ -191,7 +193,7 @@ const removeOwnedDiscovery = async (dir, path, record) => {
             // Re-check the directory entry against the already-open, verified inode. Cooperating writers are
             // serialized by the lock; this check also refuses an uncooperative symlink/replacement race.
             const linked = lstatSync(path);
-            if (!linked.isFile() || linked.isSymbolicLink() || linked.dev !== opened.dev || linked.ino !== opened.ino)
+            if (!linked.isFile() || linked.isSymbolicLink() || !sameOpenedFileIdentity(linked, opened))
                 return;
             unlinkSync(path);
             syncDirectory(dir);
@@ -301,31 +303,58 @@ export async function startServe(opts, deps) {
             throw error;
         }
     }
+    /** Move accepted steering from the task inbox into a write-ahead transcript snapshot. The caller either
+     *  appends the returned messages to live history or returns them to runAgent for that append. A crash can
+     *  therefore recover pending inbox state or consumed transcript state, never lose an acknowledged input. */
+    const materializePendingSteering = (s) => {
+        const consumed = consumePendingTaskSteering(s.task);
+        if (!consumed)
+            return [];
+        const messages = consumed.entries.map((entry) => ({
+            role: "user",
+            content: `${INTERJECT_PREFIX}\n\n${entry.content}`,
+        }));
+        hub.saveSnapshot(s, [...s.history, ...messages], consumed.task);
+        s.task = consumed.task;
+        s.history.push(...messages);
+        return messages;
+    };
     /** Run one turn on a session, streaming events to all authed clients. */
     const runTurn = async (s, text, images, forceNewTask = false) => {
         const sessionId = s.meta.id;
         s.busy = true;
         const turnAbort = new AbortController();
         s.abort = turnAbort;
-        s.pendingInput = [];
-        const interaction = !forceNewTask && s.resumeTaskPending && s.task
-            ? newSteerInteraction(s.task.turnId)
-            : newTurnInteraction();
-        if (interaction.kind === "steer") {
-            const continued = continueTaskExecution(s.task, interaction);
-            if (!continued.ok) {
-                s.abort = null;
-                s.busy = false;
-                throw new Error(continued.reason);
+        let interaction;
+        let executionContext;
+        try {
+            const recoveredSteering = materializePendingSteering(s);
+            interaction = !forceNewTask && s.task && s.task.status !== "completed" &&
+                (recoveredSteering.length > 0 || requestsTaskContinuation(text))
+                ? newSteerInteraction(s.task.turnId)
+                : newTurnInteraction();
+            if (interaction.kind === "steer") {
+                const continued = continueTaskExecution(s.task, interaction);
+                if (!continued.ok)
+                    throw new Error(continued.reason);
+                s.task = continued.task;
             }
-            s.task = continued.task;
+            else {
+                s.task = createTaskExecution(text, interaction.turnId);
+                // Checklists belong to executions, not to the surrounding conversation thread. An unrelated task
+                // must not inherit old pending todos and be forced back into paused state after a successful turn.
+                s.meta.todos = [];
+            }
+            executionContext = taskExecutionContext(s.task, interaction, s.meta.todos ?? []);
+            hub.save(s); // crash-safe running identity before provider/tool side effects
         }
-        else {
-            s.task = createTaskExecution(text, interaction.turnId);
+        catch (error) {
+            // Initialization happens before the main turn try/finally. Release the session here as well so a
+            // transient snapshot/config error cannot wedge it in a permanently busy, non-interruptible state.
+            s.abort = null;
+            s.busy = false;
+            throw error;
         }
-        s.resumeTaskPending = false;
-        const executionContext = taskExecutionContext(s.task, interaction);
-        hub.save(s); // crash-safe running identity before provider/tool side effects
         broadcast("event.turn_start", { sessionId, taskId: s.task.id, turnId: s.task.turnId });
         const historyStart = s.history.length;
         const before = { input: s.stats.input, output: s.stats.output };
@@ -400,7 +429,10 @@ export async function startServe(opts, deps) {
                     memory: memoryDigest(s.meta.cwd),
                     continuationSession: s.continuationSession,
                     executionContext,
-                    pendingInput: async () => s.pendingInput.splice(0),
+                    pendingInput: async () => {
+                        materializePendingSteering(s); // helper updates the shared live history after its write-ahead save
+                        return [];
+                    },
                     stats: s.stats,
                     signal: turnAbort.signal,
                     onProviderTurn: (turn) => {
@@ -430,15 +462,12 @@ export async function startServe(opts, deps) {
                 });
                 // A steer may land after the agent's final in-loop drain but before the logical turn returns. Keep
                 // it in the same task/run instead of making the client retry it as an unrelated session.send.
-                const trailing = s.pendingInput.splice(0);
+                const trailing = materializePendingSteering(s);
                 if (!trailing.length || turnAbort.signal.aborted || outcome.status !== "completed")
                     break;
-                s.history.push(...trailing);
-                hub.save(s);
             } while (true);
             s.meta.todos = serializeTodos(sessionId);
             s.task = finishTaskExecution(s.task, outcome, s.meta.todos, turnAbort.signal.aborted);
-            s.resumeTaskPending = Boolean(s.task && s.task.status !== "completed");
             hub.save(s);
             const usage = { input: s.stats.input - before.input, output: s.stats.output - before.output };
             // context watermark rides along with every turn end (codex thread/tokenUsage/updated pattern) —
@@ -462,7 +491,6 @@ export async function startServe(opts, deps) {
         catch (error) {
             if (s.task?.status === "running") {
                 s.task = finishTaskExecution(s.task, { status: "error", error: error instanceof Error ? error.message : String(error) }, s.meta.todos ?? [], turnAbort.signal.aborted);
-                s.resumeTaskPending = Boolean(s.task && s.task.status !== "completed");
                 hub.save(s);
             }
             throw error;
@@ -482,6 +510,7 @@ export async function startServe(opts, deps) {
      *  cwd because serve is multi-session (recentTouched is process-wide and must not leak across projects). */
     const compactSession = async (s, controller) => {
         const timeoutMs = Math.max(1, Math.min(deps.compactTimeoutMs ?? COMPACT_TIMEOUT_MS, COMPACT_TIMEOUT_MS));
+        const recent = recentHistoryForCompaction(s.history);
         const r = await new Promise((resolve, reject) => {
             let settled = false;
             let timedOut = false;
@@ -511,7 +540,7 @@ export async function startServe(opts, deps) {
                     throw new Error(timedOut ? "compaction timed out" : "compaction interrupted");
                 return s.provider.turn({
                     system: COMPACT_SYSTEM,
-                    history: [...s.history, { role: "user", content: "Summarize our conversation so far per the instructions." }],
+                    history: [...compactionSourceHistory(s.history), { role: "user", content: "Create the bounded execution checkpoint now." }],
                     tools: [],
                     onText: () => { },
                     signal: controller.signal,
@@ -520,9 +549,10 @@ export async function startServe(opts, deps) {
         });
         if (controller.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);
         const touched = recentTouched(20, s.meta.id).filter((file) => {
             const rel = relative(s.meta.cwd, file);
@@ -541,13 +571,12 @@ export async function startServe(opts, deps) {
         if (controller.signal.aborted)
             return null;
         s.meta.workingSet = workingSet;
+        const compacted = compactedConversationHistory(summary, recent, restore);
         s.history.length = 0;
-        s.history.push({ role: "user", content: `Summary of our conversation so far (continue from here):\n\n${summary}` });
-        if (restore)
-            s.history.push({ role: "user", content: restore });
+        s.history.push(...compacted);
         s.stats.input += r.usage?.input ?? 0;
         s.stats.output += r.usage?.output ?? 0;
-        s.stats.lastInput = r.usage?.input ?? 0; // ctx% now reflects the (small) summary
+        s.stats.lastInput = compactedHistoryTokenEstimate(compacted);
         hub.save(s);
         return summary;
     };
@@ -679,8 +708,7 @@ export async function startServe(opts, deps) {
                             if (!recorded.ok)
                                 return reply(rpcError(id, ERR.BUSY, recorded.reason));
                             s.task = recorded.task;
-                            s.pendingInput.push({ role: "user", content: `${INTERJECT_PREFIX}\n\n${expanded}` });
-                            hub.save(s); // task audit is durable even before the running loop reaches its next drain
+                            hub.save(s); // executable inbox entry is durable before ACK
                             return reply(rpcResult(id, { accepted: true, taskId: s.task.id, turnId: s.task.turnId }));
                         }
                         case "session.interrupt": {
@@ -969,8 +997,6 @@ export async function startServe(opts, deps) {
                             s.history.length = 0;
                             s.history.push(...next);
                             s.task = undefined;
-                            s.resumeTaskPending = false;
-                            s.pendingInput = [];
                             hub.save(s);
                             return reply(rpcResult(id, { sessionId: s.meta.id, history: historyForClient(s.history) }));
                         }

package/dist/serve/sessions.js

@@ -48,7 +48,7 @@ export class SessionHub {
         const lock = this.store.acquire(meta.id); // fresh UUID, but filesystem errors must still fail closed
         if (!lock.ok)
             throw new Error(`could not acquire session lock for ${meta.id}${lock.pid ? ` (held by pid ${lock.pid})` : ""}`);
-        const s = { meta, history: [], resumeTaskPending: false, pendingInput: [], provider: o.provider, approval: o.approval, autoApprove: new Set(), stats: { input: 0, output: 0 }, projectContext: o.projectContext, continuationSession: false, busy: false, configuring: false, pendingProviderTurns: 0, pendingToolRuns: 0, abort: null };
+        const s = { meta, history: [], provider: o.provider, approval: o.approval, autoApprove: new Set(), stats: { input: 0, output: 0 }, projectContext: o.projectContext, continuationSession: false, busy: false, configuring: false, pendingProviderTurns: 0, pendingToolRuns: 0, abort: null };
         try {
             this.sessions.set(meta.id, s);
             this.store.save(meta, []); // an empty newly-created thread must survive restart and appear in lists
@@ -78,7 +78,7 @@ export class SessionHub {
             // Credential/provider routing is live, while the model remains the session's explicit pin.
             prior.meta.provider = o.provider.id;
             const task = recoverTaskExecution(prior.task);
-            const s = { meta: prior.meta, history: [...prior.history], task, resumeTaskPending: Boolean(task && task.status !== "completed"), pendingInput: [], provider: o.provider, approval: o.approval, autoApprove: new Set(), stats: { input: 0, output: 0 }, projectContext: o.projectContext, continuationSession: prior.history.length > 0, busy: false, configuring: false, pendingProviderTurns: 0, pendingToolRuns: 0, abort: null, effort: prior.meta.effort };
+            const s = { meta: prior.meta, history: [...prior.history], task, provider: o.provider, approval: o.approval, autoApprove: new Set(), stats: { input: 0, output: 0 }, projectContext: o.projectContext, continuationSession: prior.history.length > 0, busy: false, configuring: false, pendingProviderTurns: 0, pendingToolRuns: 0, abort: null, effort: prior.meta.effort };
             this.sessions.set(id, s);
             keepLock = true; // live session owns it until delete/releaseAll
             return { session: s };
@@ -118,6 +118,16 @@ export class SessionHub {
         }
         this.store.save(s.meta, s.history, s.task);
     }
+    /** Persist a projected transcript/task transition without mutating the live arrays first. Steering uses
+     *  this write-ahead snapshot so an accepted inbox item is durable in history before runAgent observes it. */
+    saveSnapshot(s, history, task) {
+        if (!s.meta.title) {
+            const first = history.find((m) => m.role === "user");
+            if (first && "content" in first && typeof first.content === "string")
+                s.meta.title = deriveTitle(first.content);
+        }
+        this.store.save(s.meta, history, task);
+    }
     /** Rename a session (live or on-disk). Returns false when the id is unknown. */
     rename(id, title) {
         const live = this.sessions.get(id);
@@ -175,8 +185,6 @@ export class SessionHub {
             meta,
             history: [...src.history],
             task: forkTaskExecution(src.task),
-            resumeTaskPending: Boolean(src.task),
-            pendingInput: [],
             provider: o.provider,
             approval: o.approval,
             autoApprove: new Set(),

package/dist/session/store.js

@@ -370,6 +370,10 @@ function redactedSessionCopy(data) {
                 target.id = source.id;
                 target.turnId = source.turnId;
                 target.createdAt = source.createdAt;
+                if (source.deliveryState !== undefined)
+                    target.deliveryState = source.deliveryState;
+                if (source.consumedAt !== undefined)
+                    target.consumedAt = source.consumedAt;
             }
         }
     }

package/dist/session/task.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 export const TASK_SCHEMA_VERSION = 1;
 export const MAX_TASK_OBJECTIVE_CHARS = 4096;
-export const MAX_TASK_STEERING_CHARS = 4096;
+export const MAX_TASK_STEERING_CHARS = 24_000;
 export const MAX_TASK_STEERING_ENTRIES = 24;
 function iso(at = new Date()) {
     return typeof at === "string" ? at : at.toISOString();
@@ -63,13 +63,56 @@ export function recordTaskSteering(task, expectedTurnId, content, at = new Date(
     if (task.turnId !== expectedTurnId) {
         return { ok: false, reason: `stale steer for turn ${expectedTurnId}; active turn is ${task.turnId}` };
     }
+    const normalized = content.replace(/\r\n?/g, "\n").trim() || "(image-only steering)";
+    if (normalized.length > MAX_TASK_STEERING_CHARS) {
+        return { ok: false, reason: `steering input is too large (${normalized.length} chars; maximum ${MAX_TASK_STEERING_CHARS})` };
+    }
     const now = iso(at);
     const steering = [
         ...(task.steering ?? []),
-        { id: randomUUID(), turnId: expectedTurnId, content: boundedText(content, MAX_TASK_STEERING_CHARS), createdAt: now },
-    ].slice(-MAX_TASK_STEERING_ENTRIES);
+        {
+            id: randomUUID(),
+            turnId: expectedTurnId,
+            content: normalized,
+            createdAt: now,
+            deliveryState: "pending",
+        },
+    ];
+    // Never silently evict accepted-but-undelivered input. Prefer dropping the oldest consumed/legacy audit
+    // entry; if all slots are pending, apply backpressure and let the caller surface a retryable queue-full
+    // error instead of acknowledging data that cannot be retained.
+    if (steering.length > MAX_TASK_STEERING_ENTRIES) {
+        const removable = steering.findIndex((entry) => entry.deliveryState !== "pending");
+        if (removable < 0)
+            return { ok: false, reason: `task steering inbox is full (${MAX_TASK_STEERING_ENTRIES}); wait for the running turn to consume it` };
+        steering.splice(removable, 1);
+    }
     return { ok: true, task: { ...task, steering, updatedAt: now } };
 }
+/** Mark every accepted inbox entry consumed in one immutable transition. Callers persist the projected
+ *  transcript plus this returned task before exposing the messages to the agent loop, making delivery
+ *  crash-safe and exactly-once. Legacy entries without deliveryState remain audit-only. */
+export function consumePendingTaskSteering(task, at = new Date()) {
+    if (!task?.steering?.some((entry) => entry.deliveryState === "pending"))
+        return null;
+    const now = iso(at);
+    const entries = task.steering.filter((entry) => entry.deliveryState === "pending").map((entry) => ({ ...entry }));
+    const steering = task.steering.map((entry) => entry.deliveryState === "pending"
+        ? { ...entry, deliveryState: "consumed", consumedAt: now }
+        : entry);
+    return { task: { ...task, steering, updatedAt: now }, entries };
+}
+export function hasPendingTaskSteering(task) {
+    return !!task?.steering?.some((entry) => entry.deliveryState === "pending");
+}
+/** Idle messages start a new task by default. Only an explicit continuation phrase resumes an unfinished
+ *  execution, matching Codex's separation between steering an active turn and starting the next task. */
+export function requestsTaskContinuation(text) {
+    const value = text.trim().toLocaleLowerCase();
+    if (!value)
+        return false;
+    return /^(?:\/(?:continue|resume)(?:\s|$)|(?:continue|resume|go\s+on)(?:[\s,.:;!?，。：；！？]|$)|(?:继续|接着|接着做|继续处理)(?:[\s,.:;!?，。：；！？]|$))/.test(value);
+}
 export function finishTaskExecution(task, outcome, todos = [], interrupted = false, at = new Date()) {
     if (!task)
         return undefined;
@@ -106,14 +149,18 @@ export function forkTaskExecution(task, at = new Date()) {
         startedAt: now,
         endedAt: now,
         lastOutcome: "interrupted",
-        steering: task.steering?.slice(-MAX_TASK_STEERING_ENTRIES).map((entry) => ({ ...entry })),
+        // A fork copies audit context, never ownership of an executable inbox item. Pending steering remains
+        // pending only in the source session; replaying it in both branches would violate exactly-once delivery.
+        steering: task.steering?.slice(-MAX_TASK_STEERING_ENTRIES).map((entry) => entry.deliveryState === "pending"
+            ? { ...entry, deliveryState: "consumed", consumedAt: now }
+            : { ...entry }),
     };
 }
-export function taskExecutionContext(task, interaction) {
+export function taskExecutionContext(task, interaction, todos = []) {
     const steeringNote = interaction.kind === "steer"
         ? "This interaction steers the existing task. Refine execution without replacing its objective."
         : "This interaction created a new task.";
-    return [
+    const lines = [
         "# Task execution (authoritative; separate from conversation history)",
         `Task ID: ${task.id}`,
         `Turn ID: ${task.turnId}`,
@@ -121,7 +168,17 @@ export function taskExecutionContext(task, interaction) {
         `Interaction: ${interaction.kind}`,
         steeringNote,
         "Conversation messages provide evidence and refinements, but the task objective above remains authoritative until an explicit new task starts.",
-    ].join("\n");
+    ];
+    if (todos.length) {
+        lines.push("## Persisted execution checkpoint", ...todos.slice(0, 24).map((todo) => {
+            const mark = todo.status === "done" ? "done" : todo.status === "in_progress" ? "in progress" : "pending";
+            return `- [${mark}] ${todo.text.replace(/\s+/g, " ").trim().slice(0, 240)}`;
+        }));
+        if (todos.length > 24)
+            lines.push(`- … ${todos.length - 24} additional item(s) omitted; call todo_write to inspect/update the full list.`);
+        lines.push("Treat this checklist as the recovery cursor: continue from the first unfinished item, verify current workspace state, and update it as work changes.");
+    }
+    return lines.join("\n");
 }
 export function formatTaskExecution(task) {
     if (!task)
@@ -154,8 +211,13 @@ export function isTaskExecution(value) {
         if (!entry || typeof entry !== "object" || Array.isArray(entry))
             return false;
         const steering = entry;
+        const deliveryValid = steering.deliveryState === undefined
+            ? steering.consumedAt === undefined
+            : steering.deliveryState === "pending"
+                ? steering.consumedAt === undefined
+                : steering.deliveryState === "consumed" && validTimestamp(steering.consumedAt);
         return validId(steering.id) && validId(steering.turnId) &&
             typeof steering.content === "string" && steering.content.length > 0 && steering.content.length <= MAX_TASK_STEERING_CHARS &&
-            validTimestamp(steering.createdAt);
+            validTimestamp(steering.createdAt) && deliveryValid;
     });
 }

package/dist/tools/memory.js

@@ -11,6 +11,9 @@ import { globalSkillsDir, skillsDir, invalidateSkillsCache } from "../skills/ski
 import { sensitiveFileError } from "../security/sensitive-files.js";
 import { readModelContextFileSync, readVerifiedRegularFileSnapshot } from "../fs-read.js";
 import { atomicWriteText, bindAtomicWritePath } from "../fs-write.js";
+export const MAX_MEMORY_ENTRY_CHARS = 4_000;
+export const MAX_SKILL_DESCRIPTION_CHARS = 500;
+export const MAX_SKILL_BODY_CHARS = 24_000;
 const asTarget = (v) => (["memory", "user", "log"].includes(v) ? v : "memory");
 const asScope = (v) => (v === "global" ? "global" : "project");
 registerTool({
@@ -58,7 +61,8 @@ registerTool({
 registerTool({
     name: "memory_write",
     description: "Persist a durable fact/decision/preference to memory so future sessions recall it. Save proactively " +
-        "when you learn something worth keeping: project conventions, the user's preferences, a tricky solution.",
+        "only with evidence: use target=log for tentative/one-off observations; promote stable verified project " +
+        "conventions/decisions to memory and explicit user preferences to user. Include a short source/evidence phrase.",
     input_schema: {
         type: "object",
         properties: {
@@ -74,6 +78,9 @@ registerTool({
         const content = String(input.content ?? "").trim();
         if (!content)
             return "Error: empty content.";
+        if (content.length > MAX_MEMORY_ENTRY_CHARS) {
+            return `Error: memory entry is too large (${content.length} chars; maximum ${MAX_MEMORY_ENTRY_CHARS}). Save one concise durable fact, not a transcript or dump.`;
+        }
         const scan = scanMemory(content);
         if (!scan.ok)
             return `Blocked: this looks unsafe to store (${scan.hits.join(", ")}). Rephrase without secrets/injection text.`;
@@ -109,12 +116,20 @@ registerTool({
             .slice(0, 48);
         if (!slug)
             return "Error: invalid name.";
-        let description = String(input.description ?? "").replace(/\s+/g, " ").trim();
+        const rawDescription = String(input.description ?? "");
+        const rawBody = String(input.body ?? "");
+        if (rawDescription.length > MAX_SKILL_DESCRIPTION_CHARS) {
+            return `Error: skill description is too large (${rawDescription.length} chars; maximum ${MAX_SKILL_DESCRIPTION_CHARS}).`;
+        }
+        if (rawBody.length > MAX_SKILL_BODY_CHARS) {
+            return `Error: skill body is too large (${rawBody.length} chars; maximum ${MAX_SKILL_BODY_CHARS}). Save a focused reusable procedure, not a transcript or file dump.`;
+        }
+        let description = rawDescription.replace(/\s+/g, " ").trim();
         if (!description)
             return "Error: a description is required (it's how the skill gets surfaced).";
         // sanitize on capture: generalize local paths/emails, then redact secrets; block only on residue.
         description = scrubLocal(description, ctx.cwd);
-        let body = scrubLocal(String(input.body ?? ""), ctx.cwd);
+        let body = scrubLocal(rawBody, ctx.cwd);
         const rd = redactSecrets(description);
         const rb = redactSecrets(body);
         description = rd.text;

package/dist/tools/search.js

@@ -290,7 +290,8 @@ function execute() {
 
   const readBuffer = Buffer.allocUnsafe(cfg.maxFileBytes + 1);
   function sameIdentity(info, candidate) {
-    return String(info.dev) === candidate.dev && String(info.ino) === candidate.ino;
+    return String(info.ino) === candidate.ino
+      && (process.platform === "win32" || String(info.dev) === candidate.dev);
   }
   function safeReadText(candidate) {
     const absolute = candidate.path;
@@ -298,7 +299,10 @@ function execute() {
     try {
       const before = fs.lstatSync(absolute, { bigint: true });
       if (!before.isFile() || before.nlink !== 1n || !sameIdentity(before, candidate)) return null;
-      fd = fs.openSync(absolute, fs.constants.O_RDONLY | (fs.constants.O_NONBLOCK || 0) | (fs.constants.O_NOFOLLOW || 0));
+      const posixFlags = process.platform === "win32"
+        ? 0
+        : (fs.constants.O_NONBLOCK || 0) | (fs.constants.O_NOFOLLOW || 0);
+      fd = fs.openSync(absolute, fs.constants.O_RDONLY | posixFlags);
       const info = fs.fstatSync(fd, { bigint: true });
       if (!info.isFile() || info.nlink !== 1n || !sameIdentity(info, candidate) || info.size > BigInt(cfg.maxFileBytes)) return null;
       let total = 0;

package/dist/tui/App.js

@@ -20,7 +20,7 @@ import { clearTodos, currentTodos, onTodosChange } from "../tools/todo.js";
 import { onTurnPhase, turnPhase } from "../agent/phase.js";
 import { listJobs, onJobsChange } from "../exec/jobs.js";
 import { ModelPicker } from "./model-picker.js";
-import { newSteerInteraction, newTurnInteraction } from "../session/task.js";
+import { newSteerInteraction, newTurnInteraction, requestsTaskContinuation } from "../session/task.js";
 let _id = 0;
 const nid = () => ++_id;
 const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
@@ -290,7 +290,7 @@ function StatusRow({ working, todos, queued }) {
     // Pre-first-token honesty (codex-parity): "waiting for the model" reads very differently from a
     // generic "working" when the network is slow — the user knows the request is out, not dead.
     const verb = (phase === "waiting" ? `waiting for the model… ${elapsedSec}s · esc to interrupt` : spinnerVerb(todos, elapsedSec)) + bgTag;
-    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "yellow", children: frames[frame % frames.length] }), _jsx(Text, { dimColor: true, children: ` ${verb} · ⏎ steers task${queued ? ` (${queued})` : ""}` })] }));
+    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "yellow", children: frames[frame % frames.length] }), _jsx(Text, { dimColor: true, children: ` ${verb} · ⏎ steers · /next queues${queued ? ` (${queued})` : ""}` })] }));
 }
 // Short per-mode descriptions for the ONE-ROW mode line (the old two-row ModeBar's long sentences
 // don't fit inline). Full behavior is documented in /help; this line is a switching aid, not a manual.
@@ -462,9 +462,12 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
     const drainQueue = useCallback(() => {
         if (!queueRef.current.length)
             return [];
-        const batch = queueRef.current;
-        queueRef.current = [];
-        setPool([]);
+        const barrier = queueRef.current.findIndex((item) => item.mode === "next");
+        const batch = (barrier < 0 ? queueRef.current : queueRef.current.slice(0, barrier));
+        if (!batch.length)
+            return [];
+        queueRef.current = barrier < 0 ? [] : queueRef.current.slice(barrier);
+        setPool(queueRef.current.map((item) => `${item.mode === "next" ? "next: " : ""}${item.line.trim() || "🖼 (image)"}`));
         if (batch.some((b) => b.images?.length))
             noteVisionIfNeeded();
         for (const b of batch)
@@ -492,13 +495,24 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
         if ((!t && !images?.length) || prompt)
             return; // nothing to send, or a choice is pending
         if (working) {
-            // Bind every type-ahead message to the exact live turn. A stale message must never silently become
-            // a new task after another turn starts (Codex's expected_turn_id steering invariant).
+            // Enter steers the live turn; `/next …` creates an explicit queue barrier for a separate next task.
+            // Once such a barrier exists, later type-ahead stays behind it instead of leaking backward.
             const expectedTurnId = activeTurnRef.current;
             if (!expectedTurnId)
                 return;
-            queueRef.current.push({ line, images, expectedTurnId });
-            setPool(queueRef.current.map((q) => q.line.trim() || "🖼 (image)"));
+            const next = /^\/(?:next|queue)(?:\s+([\s\S]+))?$/.exec(t);
+            if (next && !next[1]?.trim() && !images?.length) {
+                pushCurrent("notice", "usage: /next <message>  (queues a separate task after the current turn)");
+                return;
+            }
+            const behindBarrier = queueRef.current.some((item) => item.mode === "next");
+            if (next || behindBarrier) {
+                queueRef.current.push({ mode: "next", line: next?.[1]?.trim() || line, images });
+            }
+            else {
+                queueRef.current.push({ mode: "steer", line, images, expectedTurnId });
+            }
+            setPool(queueRef.current.map((item) => `${item.mode === "next" ? "next: " : ""}${item.line.trim() || "🖼 (image)"}`));
             return;
         }
         const interaction = forcedInteraction ?? newTurnInteraction();
@@ -506,7 +520,8 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
         // Fold the previous turn's checklist NOW, at the natural boundary (a new task begins). The old
         // 30s-idle timer yanked the input box UP by the panel's height while the user was reading/typing
         // (anti-bob); folding on submit means the shrink coincides with the user's own action.
-        if (interaction.kind === "turn" && currentTodos().length) {
+        const controlCommand = /^\/[a-z][\w-]*(?:\s|$)/i.test(t);
+        if (interaction.kind === "turn" && !controlCommand && !requestsTaskContinuation(t) && currentTodos().length) {
             const list = currentTodos();
             const done = list.filter((td) => td.status === "done").length;
             setHistory((h) => [...h, { id: nid(), kind: "notice", text: `  ✓ Todos: ${done}/${list.length} done` }]);
@@ -641,9 +656,8 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
         if (activeTurnRef.current === interaction.turnId)
             activeTurnRef.current = null;
     }, [working, prompt, askText, onSubmit, pushCurrent, model, exit, drainQueue, noteVisionIfNeeded]);
-    // A message can arrive after runAgent's final pending-input drain but before the view flips to idle. Keep
-    // its original expectedTurnId and run it as a STEER continuation of that task — never as an ordinary new
-    // task inferred from queue timing.
+    // A message can arrive after runAgent's final pending-input drain but before the view flips to idle. Late
+    // steer groups retain expectedTurnId; explicit `/next` groups start ordinary task turns in FIFO order.
     useEffect(() => {
         if (working || prompt || askText || drainingRef.current || !queueRef.current.length)
             return;
@@ -651,10 +665,22 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
         const batch = queueRef.current;
         queueRef.current = [];
         setPool([]);
-        const line = batch.map((b) => b.line).join("\n\n");
-        const images = batch.flatMap((b) => b.images ?? []);
-        const expectedTurnId = batch[0].expectedTurnId;
-        void Promise.resolve(handleSubmit(line, images.length ? images : undefined, newSteerInteraction(expectedTurnId))).finally(() => {
+        void (async () => {
+            for (let at = 0; at < batch.length;) {
+                const mode = batch[at].mode;
+                let end = at + 1;
+                while (end < batch.length && batch[end].mode === mode)
+                    end++;
+                const group = batch.slice(at, end);
+                const line = group.map((item) => item.line).join("\n\n");
+                const images = group.flatMap((item) => item.images ?? []);
+                const forced = mode === "steer"
+                    ? newSteerInteraction(group[0].expectedTurnId)
+                    : undefined;
+                await handleSubmit(line, images.length ? images : undefined, forced);
+                at = end;
+            }
+        })().finally(() => {
             drainingRef.current = false;
         });
     }, [working, prompt, askText, handleSubmit]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.123.1",
+  "version": "0.124.1",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "runtime-bootstrap.cjs"