@nanhara/hara 0.117.0 → 0.118.0

package/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to `@nanhara/hara`.
 > Versioning (pre-1.0, SemVer-style): the **minor** (middle) number bumps for a **new feature**; the
 > **patch** (last) number bumps for **optimizations/fixes of existing features**.
 
+## 0.118.0 — session delete & fork · slash skills over serve
+
+- **`session.delete`** — permanent removal (codex thread/delete; archive stays the soft path).
+  Lock-aware: refuses when a live other process holds the session; busy-guarded on live turns.
+- **`session.fork`** — duplicate a session's history into a new live session (codex thread/fork),
+  rewind's non-destructive sibling: explore a different direction without losing the original.
+  Forks persist immediately.
+- **Slash skills over the wire** — `session.send` with a leading `/skill-id request…` expands into
+  the CLI's skill-entering flow, so a desktop composer's "/" popup triggers exactly what the
+  terminal gets. Unknown ids fall through as plain text.
+
 ## 0.117.0 — serve batch 3: context watermark · compact · rewind · fuzzy file search
 
 Codex-desktop parity for the conversation-hygiene set — everything a client needs to keep a long

package/dist/serve/server.js

@@ -21,7 +21,7 @@ import { loadAgentsMd } from "../context/agents-md.js";
 import { expandMentions } from "../context/mentions.js";
 import { memoryDigest } from "../memory/store.js";
 import { listInstalled, enabledPlugins, setPluginEnabled } from "../plugins/plugins.js";
-import { loadSkillIndex } from "../skills/skills.js";
+import { loadSkillIndex, loadSkillBody } from "../skills/skills.js";
 import { loadJobs, saveJobs, addJob } from "../cron/store.js";
 import { parseSchedule, describeSchedule } from "../cron/schedule.js";
 import { SessionHub, realStore } from "./sessions.js";
@@ -104,9 +104,21 @@ export async function startServe(opts, deps) {
             broadcast("approval.request", { sessionId, approvalId, question: q });
         });
         try {
+            // Slash skills, CLI parity: "/skill-id request…" expands into the skill-entering message, so a
+            // desktop composer's "/" popup triggers the exact behavior the terminal gets. Unknown ids fall
+            // through as plain text (the model sees what the user typed).
+            let content = text;
+            const slash = /^\/([a-z0-9][\w-]*)(?:\s+([\s\S]*))?$/.exec(text.trim());
+            if (slash) {
+                const sk = loadSkillIndex(s.meta.cwd).find((k) => k.id === slash[1]);
+                if (sk) {
+                    const rest = slash[2]?.trim();
+                    content = `Skill \`${sk.id}\`:\n${loadSkillBody(sk)}\n\n---\nEntering ${sk.id} mode${rest ? ` — request: ${rest}` : ""}. 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.`;
+                }
+            }
             // @file mentions expand to file contents, same as the CLI (`@src/foo.ts` in the composer works).
             // Pasted images ride along as NeutralMsg.images — a vision-capable model sees them inline.
-            s.history.push({ role: "user", content: expandMentions(text, s.meta.cwd), ...(images && images.length ? { images } : {}) });
+            s.history.push({ role: "user", content: expandMentions(content, s.meta.cwd), ...(images && images.length ? { images } : {}) });
             await runAgent(s.history, {
                 provider: s.provider,
                 ctx: {
@@ -197,7 +209,7 @@ export async function startServe(opts, deps) {
                     // (client-declared) is accepted and currently unused — reserved for opt-outs/experimental gating.
                     const methods = [
                         "session.list", "session.create", "session.resume", "session.send", "session.interrupt", "session.set-model",
-                        "session.rename", "session.archive", "session.compact", "session.rewind", "session.context",
+                        "session.rename", "session.archive", "session.compact", "session.rewind", "session.context", "session.delete", "session.fork",
                         "approval.reply", "plugins.list", "plugins.set", "skills.list", "models.list", "files.search",
                         "automation.list", "automation.add", "automation.toggle", "automation.delete",
                     ];
@@ -286,6 +298,31 @@ export async function startServe(opts, deps) {
                             return reply(rpcError(id, ERR.NO_SESSION, `no session ${p.sessionId}`));
                         return reply(rpcResult(id, { sessionId: p.sessionId, archived: p.archived }));
                     }
+                    case "session.fork": {
+                        // duplicate the conversation into a new session (codex thread/fork) — rewind's
+                        // non-destructive sibling: explore a different direction without losing the original
+                        if (typeof p.sessionId !== "string")
+                            return reply(rpcError(id, ERR.PARAMS, "sessionId required"));
+                        const provider = await deps.buildSessionProvider();
+                        if (!provider)
+                            return reply(rpcError(id, ERR.INTERNAL, "provider not authenticated — run `hara setup`"));
+                        const r = hub.fork(p.sessionId, { provider, providerId: deps.providerId, approval: deps.approval, projectContext: undefined });
+                        if ("missing" in r)
+                            return reply(rpcError(id, ERR.NO_SESSION, `no session ${p.sessionId}`));
+                        r.session.projectContext = loadAgentsMd(r.session.meta.cwd) || undefined;
+                        return reply(rpcResult(id, { sessionId: r.session.meta.id, title: r.session.meta.title, model: r.session.meta.model, history: historyForClient(r.session.history) }));
+                    }
+                    case "session.delete": {
+                        // permanent removal (codex thread/delete) — archive is the soft path; this one is forever
+                        if (typeof p.sessionId !== "string")
+                            return reply(rpcError(id, ERR.PARAMS, "sessionId required"));
+                        const r = hub.delete(p.sessionId);
+                        if (r === "busy")
+                            return reply(rpcError(id, ERR.BUSY, "a turn is running — delete after it finishes"));
+                        if (r === "missing")
+                            return reply(rpcError(id, ERR.NO_SESSION, `no session ${p.sessionId} (or held by another process)`));
+                        return reply(rpcResult(id, { sessionId: p.sessionId, deleted: true }));
+                    }
                     case "models.list": {
                         const models = deps.listModels ? await deps.listModels().catch(() => []) : [];
                         return reply(rpcResult(id, { models, current: deps.model, effortLevels: deps.effortLevels ?? [] }));

package/dist/serve/sessions.js

@@ -1,4 +1,4 @@
-import { newSessionId, saveSession, loadSession, listSessions, acquireSessionLock, releaseSessionLock, deriveTitle, } from "../session/store.js";
+import { newSessionId, saveSession, loadSession, listSessions, acquireSessionLock, releaseSessionLock, deleteSession, deriveTitle, } from "../session/store.js";
 /** The real ~/.hara/sessions store (default). */
 export const realStore = {
     load: loadSession,
@@ -6,6 +6,7 @@ export const realStore = {
     list: listSessions,
     acquire: acquireSessionLock,
     release: releaseSessionLock,
+    delete: deleteSession,
 };
 export class SessionHub {
     store;
@@ -89,6 +90,53 @@ export class SessionHub {
         this.store.save(prior.meta, prior.history);
         return true;
     }
+    /** Fork: duplicate a session's history into a NEW session (codex thread/fork) — the non-destructive
+     *  sibling of rewind. Source may be live or on-disk; the fork is always a fresh live session. */
+    fork(id, o) {
+        const live = this.sessions.get(id);
+        const src = live ?? this.store.load(id);
+        if (!src)
+            return { missing: true };
+        const meta = {
+            id: newSessionId(),
+            cwd: src.meta.cwd,
+            provider: o.providerId,
+            model: src.meta.model,
+            title: src.meta.title ? `${src.meta.title} ⑂` : "",
+            createdAt: new Date().toISOString(),
+            updatedAt: "",
+            source: "interactive",
+        };
+        this.store.acquire(meta.id);
+        const s = {
+            meta,
+            history: [...src.history],
+            provider: o.provider,
+            approval: o.approval,
+            autoApprove: new Set(),
+            stats: { input: 0, output: 0 },
+            projectContext: o.projectContext,
+            busy: false,
+            abort: null,
+        };
+        this.sessions.set(meta.id, s);
+        this.store.save(meta, s.history); // persist immediately — a fork should survive a crash unsent
+        return { session: s };
+    }
+    /** Permanently delete (live or on-disk). Refuses a busy live session. Returns:
+     *  "gone" on success, "busy" when a turn is running, "missing" when unknown/held elsewhere. */
+    delete(id) {
+        const live = this.sessions.get(id);
+        if (live?.busy)
+            return "busy";
+        const ok = this.store.delete(id);
+        if (!ok && !live)
+            return "missing";
+        if (live)
+            this.sessions.delete(id);
+        this.store.release(id);
+        return "gone";
+    }
     /** Release all locks (server shutdown). In-flight turns are aborted by the caller first. */
     releaseAll() {
         for (const id of this.sessions.keys())

package/dist/session/store.js

@@ -72,6 +72,25 @@ export function releaseSessionLock(id) {
         /* best-effort */
     }
 }
+/** Permanently delete a session from disk (codex thread/delete — unlike archive, irreversible).
+ *  Refuses when a LIVE other process holds the lock; removes the session file and any lock we may hold.
+ *  Returns false when the session doesn't exist or is held elsewhere. */
+export function deleteSession(id) {
+    const f = sessionFile(id);
+    if (!existsSync(f))
+        return false;
+    const lock = acquireSessionLock(id);
+    if (!lock.ok)
+        return false;
+    try {
+        rmSync(f);
+        rmSync(lockFile(id), { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /** A full UUID per session (the stable identity). */
 export const newSessionId = () => randomUUID();
 /** First segment of the UUID — a compact label for the status bar / `/sessions`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.117.0",
+  "version": "0.118.0",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "dist/index.js"