@nanhara/hara 0.115.0 → 0.117.0

package/CHANGELOG.md

@@ -5,6 +5,41 @@ 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.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
+session healthy without dropping to the CLI:
+
+- **Context watermark everywhere.** Every `session.send` result and `event.turn_end` now carries
+  `ctx: { lastInput, window, pct }` — how full the model's window was on the last turn. Clients
+  render a live meter with zero extra round-trips. `session.context` returns the same watermark
+  plus the spend breakdown (your messages / assistant / per-tool) on demand.
+- **`session.compact`** — the CLI's `/compact`, serve-side: summarize-and-replace with the same
+  8-section brief, working-memory notes kept on the session, and the recently-touched-file restore
+  (limited to files under the session's own cwd — serve is multi-session; nothing leaks across
+  projects). Busy-guarded like a turn.
+- **`session.rewind`** — fork the thread back to before the n-th-most-recent user turn (codex
+  `thread/rollback`). History-only; file edits are not reverted.
+- **`files.search`** — fuzzy project-file lookup (git-aware listing + the CLI's fuzzy ranker),
+  powering @-mention autocomplete in the desktop composer. Resolves the search root from an
+  explicit `cwd` or a `sessionId`.
+
+## 0.116.0 — the desktop-grade serve protocol (models · automation · rename/archive · capabilities)
+
+- **Session source stamping.** Sessions now record WHO created them (`interactive` / `gateway` / `cron`,
+  env-derived; the cron runner passes the job name along) — and automated sessions get a
+  **"name · MM-DD HH:mm" title at creation**, so a cron prompt never becomes a session title again.
+- **`hara serve` protocol, batch 2** (everything the Hara desktop app drives):
+  - `models.list` (endpoint model catalog + thinking-effort levels) and `session.set-model`
+    (per-session model/effort switch, applies next turn)
+  - `automation.list` — cron jobs with last outcome + automated sessions, for the desktop's
+    automation timeline
+  - `session.rename` + `session.archive` (archived sessions hidden from lists, kept on disk)
+  - `initialize` now advertises `capabilities.methods` — clients feature-detect instead of
+    probing for method-not-found
+  - `session.send` expands `@file` mentions (CLI parity)
+  - `session.list` carries `source` / `sourceName` / `archived`
+
 ## 0.115.0 — serve exposes plugins & skills (desktop plugin panel)
 
 - **`hara serve` protocol grows a plugin surface**: `plugins.list` (installed plugins with enabled state +

package/dist/agent/compact.js

@@ -25,6 +25,17 @@ export const COMPACT_SYSTEM = "Summarize the conversation so far into a structur
     "7. All user messages — EVERY user message so far (excluding tool results), verbatim and in order; abbreviate only huge pasted blobs with […]. These are the ground truth of intent.\n" +
     "8. Next step — the immediate next action, INCLUDING a direct verbatim quote of the user's most recent request so there is no drift.\n" +
     "Be specific and concrete. Drop the <analysis>; output only the headed summary.";
+/** Working-memory notes distilled from a compaction summary — short lines that survive the history wipe
+ *  (stored on SessionMeta.workingSet, injected into subsequent turns). Shared by the CLI /compact path
+ *  and serve's session.compact. */
+export function workingSetFromSummary(s) {
+    return s
+        .split("\n")
+        .map((l) => l.replace(/^[-*\d.\s]+/, "").trim())
+        .filter((l) => l.length > 3)
+        .slice(0, 12)
+        .map((l) => l.slice(0, 140));
+}
 /** Post-compaction file restore (Claude Code's TW5): re-attach the CURRENT content of the files the
  *  conversation was just working with, so the summary isn't the model's only anchor — it doesn't have
  *  to re-read its own working set next turn (and can't act on a stale memory of an edited file).

package/dist/cron/runner.js

@@ -55,7 +55,9 @@ export function runJobOnce(job) {
         const [cmd, argv] = job.mode === "command"
             ? ["bash", ["-lc", job.task]]
             : [self[0], [...self.slice(1), ...(job.mode === "org" ? ["org", job.task] : ["-p", job.task, "--approval", "full-auto"])]];
-        const child = spawn(cmd, argv, { cwd: job.cwd, env: { ...process.env, HARA_CRON: "1" } });
+        // HARA_CRON_NAME rides along so the child session's meta gets a human title ("job name · time")
+        // instead of the raw prompt (session store's automated-title strategy).
+        const child = spawn(cmd, argv, { cwd: job.cwd, env: { ...process.env, HARA_CRON: "1", HARA_CRON_NAME: job.name } });
         let tail = ""; // last few KB, for chat delivery (the full stream goes to the log file)
         const append = (d) => {
             tail = (tail + d.toString()).slice(-4_000);

package/dist/index.js

@@ -24,7 +24,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 } from "./agent/compact.js";
+import { shouldAutoCompact, shouldAutoCompactTokens, AUTO_COMPACT_TOKEN_CAP, COMPACT_SYSTEM, buildFileRestore, workingSetFromSummary } from "./agent/compact.js";
 import { recentTouched } from "./agent/touched.js";
 import { INTERJECT_PREFIX } from "./agent/reminders.js";
 import { checkForUpdate } from "./update-check.js";
@@ -45,6 +45,7 @@ import { EXPLORE_SYSTEM } from "./tools/agent.js";
 import { createAnthropicProvider } from "./providers/anthropic.js";
 import { createOpenAIProvider } from "./providers/openai.js";
 import { resolvePlatform } from "./providers/registry.js";
+import { levelsFor } from "./tui/model-picker.js";
 import { listModels } from "./providers/models.js";
 import { listJobs, tailJob, killJob } from "./exec/jobs.js";
 /** Render the background-job list for /jobs (user-facing view of what the agent has running in the
@@ -67,7 +68,7 @@ import { getEmbedder } from "./search/embed.js";
 import { collectRepoChunks, collectDirChunks, buildIndex, indexPath, indexExists } from "./search/semindex.js";
 import { searchHybrid } from "./search/hybrid.js";
 import { expandMentions, fileCandidates, isSlashCommand, inlineLeadingPath } from "./context/mentions.js";
-import { newSessionId, shortId, resolveSessionId, saveSession, loadSession, acquireSessionLock, releaseSessionLock, listSessions, latestForCwd, titleFrom, slugify, } from "./session/store.js";
+import { newSessionId, shortId, resolveSessionId, saveSession, loadSession, acquireSessionLock, releaseSessionLock, listSessions, latestForCwd, titleFrom, sessionSourceFromEnv, automatedTitle, slugify, } from "./session/store.js";
 import { setSessionForceModel, isSessionForceModel, effectiveRoleModel } from "./session/session-model.js";
 import { loadRoles, scaffoldRoles, subagentToolFilter } from "./org/roles.js";
 import { loadSkillIndex, loadSkillBody, scaffoldSkills, globalSkillsDir } from "./skills/skills.js";
@@ -757,13 +758,8 @@ const MEMORY_DISTILL_SYSTEM = "You consolidate an agent's short-term daily memor
     "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) lives in agent/compact.ts so tests can pin its structure.
-const workingSetFromSummary = (s) => s
-    .split("\n")
-    .map((l) => l.replace(/^[-*\d.\s]+/, "").trim())
-    .filter((l) => l.length > 3)
-    .slice(0, 12)
-    .map((l) => l.slice(0, 140));
+// 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.
 /** 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) {
@@ -1579,6 +1575,9 @@ program
         providerId: cfg.provider,
         model: cfg.model,
         buildSessionProvider: async () => withRouting(await buildProvider(cfg), cfg),
+        buildProviderFor: async (model, effort) => withRouting(await buildProvider({ ...cfg, model, reasoningEffort: effort ?? cfg.reasoningEffort }), cfg),
+        listModels: () => listModels(cfg.baseURL ?? providerDefaultBaseURL(cfg.provider), cfg.apiKey ?? ""),
+        effortLevels: levelsFor(resolvePlatform(cfg.provider, cfg.baseURL ?? providerDefaultBaseURL(cfg.provider)).reasoning).filter((e) => !!e),
         spawnSubagent: (provider, scwd, projectContext, stats, task, role) => runSubagent(cfg, provider, scwd, sandbox, projectContext, stats, task, role),
         guardian: guardianOpt,
         sandbox,
@@ -2251,7 +2250,19 @@ program.action(async (opts) => {
             const prior = rid ? loadSession(rid) : null;
             if (prior?.history)
                 history.push(...prior.history);
-            meta = prior?.meta ?? { id: rid ?? newSessionId(), cwd, provider: cfg.provider, model: cfg.model, title: "", createdAt: new Date().toISOString(), updatedAt: "" };
+            // Stamp who created this session (cron runner sets HARA_CRON, gateway sets HARA_GATEWAY) and give
+            // automated sessions a "name · time" title UP FRONT — the raw prompt must never become the title.
+            const src = sessionSourceFromEnv();
+            meta = prior?.meta ?? {
+                id: rid ?? newSessionId(),
+                cwd,
+                provider: cfg.provider,
+                model: cfg.model,
+                title: src.source === "interactive" ? "" : automatedTitle(src.source, src.sourceName),
+                createdAt: new Date().toISOString(),
+                updatedAt: "",
+                ...(src.source !== "interactive" ? { source: src.source, sourceName: src.sourceName } : { source: "interactive" }),
+            };
             // Apply per-session pinned model on headless resume (mirrors the interactive path).
             // --model flag wins (already on cfg.model) and is written back; otherwise restore meta.model.
             if (prior) {
@@ -2431,6 +2442,7 @@ program.action(async (opts) => {
         title: "",
         createdAt: new Date().toISOString(),
         updatedAt: "",
+        source: "interactive",
     };
     // Single-writer guard: two hara processes on the SAME session race writes to its append-only history and
     // corrupt it. Lock it here (a brand-new session's id is unique, so this only ever blocks a DOUBLE-resume

package/dist/serve/protocol.js

@@ -3,16 +3,27 @@
 // Everything here is PURE (parse + frame builders + error codes) and unit-tested.
 //
 // Client → server requests:
-//   initialize        {token}                    → {name,version,protocol,cwd,provider,model}
+//   initialize        {token,capabilities?}      → {name,version,protocol,cwd,provider,model,
+//                                                   capabilities:{methods:[…]}}  (feature detection)
 //   session.list      {cwd?}                     → {sessions:[{id,title,cwd,model,updatedAt}]}
 //   session.create    {cwd?,approval?}           → {sessionId,model}
 //   session.resume    {sessionId}                → {sessionId,model,history:[{role,text}]}
-//   session.send      {sessionId,text}           → (streams events, then) {reply,usage}
+//   session.send      {sessionId,text,images?}   → (streams events, then) {reply,usage}
+//                      images: [{path,mediaType?}] — pasted screenshots etc., inlined for vision models
 //   session.interrupt {sessionId}                → {}
 //   approval.reply    {approvalId,allow,always?}  → {}
 //   plugins.list      {}                          → {plugins:[{name,version,description,enabled,skills,agents,mcpServers}]}
 //   plugins.set       {name,enabled}              → {name,enabled}   (applies to future sessions/turns)
 //   skills.list       {cwd?}                      → {skills:[{id,description,source}]}
+//   automation.list   {}                          → {jobs:[{id,name,mode,enabled,lastRunAt,lastStatus,…}],
+//                                                    sessions:[{id,title,source,sourceName,updatedAt,…}]}
+//   models.list       {}                          → {models:[…], current, effortLevels:[…]}
+//   automation.add    {name,schedule,task,mode?,cwd?,tz?} → {id,name,schedule}
+//   automation.toggle {id,enabled}                → {id,enabled}
+//   automation.delete {id}                        → {id,deleted}
+//   session.rename    {sessionId,title}           → {sessionId,title}
+//   session.archive   {sessionId,archived}        → {sessionId,archived}   (list hides archived unless {archived:true})
+//   session.set-model {sessionId,model?,effort?}  → {sessionId,model,effort} (next turn; refused mid-turn)
 // Server → client notifications (all carry sessionId):
 //   event.text / event.reasoning {delta} · event.tool {name,preview} · event.diff {text}
 //   event.notice {text} · event.turn_end {reply,usage,error?} · approval.request {approvalId,question}

package/dist/serve/server.js

@@ -5,15 +5,25 @@
 // (no import cycle back into the CLI entry).
 import { WebSocketServer } from "ws";
 import { randomBytes, randomUUID, timingSafeEqual, createHash } from "node:crypto";
-import { writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { writeFileSync, unlinkSync, mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } 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 { rewindTo } from "../agent/rewind.js";
+import { analyzeContext } from "../agent/context-report.js";
+import { recentTouched } from "../agent/touched.js";
+import { contextWindow, ctxPctFor } from "../statusbar.js";
+import { listProjectFiles } from "../fs-walk.js";
+import { fuzzyRank } from "../fuzzy.js";
 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 { loadJobs, saveJobs, addJob } from "../cron/store.js";
+import { parseSchedule, describeSchedule } from "../cron/schedule.js";
 import { SessionHub, realStore } from "./sessions.js";
 import { parseFrame, rpcResult, rpcError, rpcNotify, ERR, PROTOCOL_VERSION } from "./protocol.js";
 const APPROVAL_TIMEOUT_MS = 300_000; // an unanswered approval denies after 5 min (never hangs a turn)
@@ -68,7 +78,7 @@ export async function startServe(opts, deps) {
         writeFileSync(discoveryPath, JSON.stringify({ host: opts.host, port, token, pid: process.pid, version: deps.version }, null, 2), { mode: 0o600 });
     }
     /** Run one turn on a session, streaming events to all authed clients. */
-    const runTurn = async (s, text) => {
+    const runTurn = async (s, text, images) => {
         const sessionId = s.meta.id;
         s.busy = true;
         s.abort = new AbortController();
@@ -94,7 +104,9 @@ export async function startServe(opts, deps) {
             broadcast("approval.request", { sessionId, approvalId, question: q });
         });
         try {
-            s.history.push({ role: "user", content: text });
+            // @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 } : {}) });
             await runAgent(s.history, {
                 provider: s.provider,
                 ctx: {
@@ -115,14 +127,57 @@ export async function startServe(opts, deps) {
             hub.save(s);
             const usage = { input: s.stats.input - before.input, output: s.stats.output - before.output };
             const reply = lastAssistantText(s.history);
-            broadcast("event.turn_end", { sessionId, reply, usage });
-            return { reply, usage };
+            // context watermark rides along with every turn end (codex thread/tokenUsage/updated pattern) —
+            // clients render a meter without an extra round-trip.
+            const ctx = ctxOf(s);
+            broadcast("event.turn_end", { sessionId, reply, usage, ctx });
+            return { reply, usage, ctx };
         }
         finally {
             s.busy = false;
             s.abort = null;
         }
     };
+    /** Context watermark for a session: how full the model's window was on the last turn. */
+    const ctxOf = (s) => {
+        const lastInput = s.stats.lastInput ?? 0;
+        return { lastInput, window: contextWindow(s.meta.model), pct: ctxPctFor(s.meta.model, lastInput) };
+    };
+    /** Summarize + replace a session's history — the CLI's /compact, serve-side (codex thread/compact).
+     *  Mirrors index.ts compactConversation; the file restore is limited to files under the session's own
+     *  cwd because serve is multi-session (recentTouched is process-wide and must not leak across projects). */
+    const compactSession = async (s) => {
+        const r = await s.provider.turn({
+            system: COMPACT_SYSTEM,
+            history: [...s.history, { role: "user", content: "Summarize our conversation so far per the instructions." }],
+            tools: [],
+            onText: () => { },
+        });
+        if (r.stop === "error")
+            return null;
+        const summary = r.text.trim();
+        if (!summary)
+            return null;
+        s.meta.workingSet = workingSetFromSummary(summary);
+        s.history.length = 0;
+        s.history.push({ role: "user", content: `Summary of our conversation so far (continue from here):\n\n${summary}` });
+        const touched = recentTouched(20).filter((f) => f.startsWith(s.meta.cwd)).slice(0, 5);
+        const restore = buildFileRestore(touched, (f) => {
+            try {
+                return readFileSync(f, "utf8");
+            }
+            catch {
+                return null;
+            }
+        });
+        if (restore)
+            s.history.push({ role: "user", content: restore });
+        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
+        hub.save(s);
+        return summary;
+    };
     wss.on("connection", (ws) => {
         ws.on("message", async (raw) => {
             const parsed = parseFrame(String(raw));
@@ -137,13 +192,22 @@ export async function startServe(opts, deps) {
                     if (typeof p.token !== "string" || !sameToken(p.token, token))
                         return reply(rpcError(id, ERR.UNAUTHORIZED, "bad token"));
                     authed.add(ws);
-                    return reply(rpcResult(id, { name: "hara", version: deps.version, protocol: PROTOCOL_VERSION, cwd: opts.cwd, provider: deps.providerId, model: deps.model }));
+                    // capability negotiation (codex app-server pattern): the server ADVERTISES its method set so
+                    // clients feature-detect up front instead of probing for -32601 per call. `p.capabilities`
+                    // (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",
+                        "approval.reply", "plugins.list", "plugins.set", "skills.list", "models.list", "files.search",
+                        "automation.list", "automation.add", "automation.toggle", "automation.delete",
+                    ];
+                    return reply(rpcResult(id, { name: "hara", version: deps.version, protocol: PROTOCOL_VERSION, cwd: opts.cwd, provider: deps.providerId, model: deps.model, capabilities: { methods } }));
                 }
                 if (!authed.has(ws))
                     return reply(rpcError(id, ERR.UNAUTHORIZED, "initialize first"));
                 switch (req.method) {
                     case "session.list":
-                        return reply(rpcResult(id, { sessions: hub.list(typeof p.cwd === "string" ? p.cwd : undefined).map((m) => ({ id: m.id, title: m.title, cwd: m.cwd, model: m.model, updatedAt: m.updatedAt })) }));
+                        return reply(rpcResult(id, { sessions: hub.list(typeof p.cwd === "string" ? p.cwd : undefined).filter((m) => !m.archived || p.archived === true).map((m) => ({ id: m.id, title: m.title, cwd: m.cwd, model: m.model, updatedAt: m.updatedAt, source: m.source ?? "interactive", sourceName: m.sourceName, archived: m.archived ?? false })) }));
                     case "session.create": {
                         const provider = await deps.buildSessionProvider();
                         if (!provider)
@@ -175,7 +239,10 @@ export async function startServe(opts, deps) {
                             return reply(rpcError(id, ERR.NO_SESSION, `no live session ${p.sessionId} — session.create/resume first`));
                         if (s.busy)
                             return reply(rpcError(id, ERR.BUSY, "a turn is already running on this session"));
-                        const r = await runTurn(s, p.text);
+                        const images = Array.isArray(p.images)
+                            ? p.images.filter((im) => im && typeof im.path === "string").map((im) => ({ path: im.path, mediaType: typeof im.mediaType === "string" ? im.mediaType : "image/png" }))
+                            : undefined;
+                        const r = await runTurn(s, p.text, images);
                         return reply(rpcResult(id, r));
                     }
                     case "session.interrupt": {
@@ -195,7 +262,7 @@ export async function startServe(opts, deps) {
                     }
                     case "plugins.list": {
                         const on = new Set(enabledPlugins().map((pl) => pl.name));
-                        return reply(rpcResult(id, { plugins: listInstalled().map((pl) => ({ name: pl.name, version: pl.version, description: pl.manifest.description ?? "", enabled: on.has(pl.name), skills: (pl.manifest.skills ?? []).length, agents: (pl.manifest.agents ?? []).length, mcpServers: Object.keys(pl.manifest.mcpServers ?? {}).length })) }));
+                        return reply(rpcResult(id, { plugins: listInstalled().map((pl) => ({ name: pl.name, version: pl.version, description: pl.manifest.description ?? "", enabled: on.has(pl.name), skills: (pl.manifest.skills ?? []).length, agents: (pl.manifest.agents ?? []).length, mcpServers: Object.keys(pl.manifest.mcpServers ?? {}).length, panels: pl.manifest.panels ?? [] })) }));
                     }
                     case "plugins.set": {
                         if (typeof p.name !== "string" || typeof p.enabled !== "boolean")
@@ -205,10 +272,160 @@ export async function startServe(opts, deps) {
                         setPluginEnabled(p.name, p.enabled);
                         return reply(rpcResult(id, { name: p.name, enabled: p.enabled })); // takes effect on the next session/turn (loaders re-read)
                     }
+                    case "session.rename": {
+                        if (typeof p.sessionId !== "string" || typeof p.title !== "string")
+                            return reply(rpcError(id, ERR.PARAMS, "sessionId + title required"));
+                        if (!hub.rename(p.sessionId, p.title.slice(0, 120)))
+                            return reply(rpcError(id, ERR.NO_SESSION, `no session ${p.sessionId}`));
+                        return reply(rpcResult(id, { sessionId: p.sessionId, title: p.title.slice(0, 120) }));
+                    }
+                    case "session.archive": {
+                        if (typeof p.sessionId !== "string" || typeof p.archived !== "boolean")
+                            return reply(rpcError(id, ERR.PARAMS, "sessionId + archived required"));
+                        if (!hub.setArchived(p.sessionId, p.archived))
+                            return reply(rpcError(id, ERR.NO_SESSION, `no session ${p.sessionId}`));
+                        return reply(rpcResult(id, { sessionId: p.sessionId, archived: p.archived }));
+                    }
+                    case "models.list": {
+                        const models = deps.listModels ? await deps.listModels().catch(() => []) : [];
+                        return reply(rpcResult(id, { models, current: deps.model, effortLevels: deps.effortLevels ?? [] }));
+                    }
+                    case "session.set-model": {
+                        // per-session model / thinking-effort switch (the composer picker). Rebuilds the session's
+                        // provider; takes effect on the NEXT turn. Refused mid-turn.
+                        if (typeof p.sessionId !== "string")
+                            return reply(rpcError(id, ERR.PARAMS, "sessionId required"));
+                        const s = hub.get(p.sessionId);
+                        if (!s)
+                            return reply(rpcError(id, ERR.NO_SESSION, `no live session ${p.sessionId}`));
+                        if (s.busy)
+                            return reply(rpcError(id, ERR.BUSY, "a turn is running — switch after it finishes"));
+                        const model = typeof p.model === "string" && p.model ? p.model : s.meta.model;
+                        const effort = typeof p.effort === "string" && p.effort ? p.effort : undefined;
+                        if (!deps.buildProviderFor)
+                            return reply(rpcError(id, ERR.METHOD, "model switching not supported by this server"));
+                        const provider = await deps.buildProviderFor(model, effort);
+                        if (!provider)
+                            return reply(rpcError(id, ERR.INTERNAL, `could not build provider for ${model}`));
+                        s.provider = provider;
+                        s.meta.model = model;
+                        s.effort = effort;
+                        return reply(rpcResult(id, { sessionId: s.meta.id, model, effort: effort ?? null }));
+                    }
+                    case "automation.list": {
+                        // The automation timeline's data: cron jobs with their last outcome, plus this machine's
+                        // automated sessions (source=cron/gateway) so the desktop can render results and "continue
+                        // as conversation". Read-only.
+                        const jobs = loadJobs().map((j) => ({ id: j.id, name: j.name, mode: j.mode, cwd: j.cwd, enabled: j.enabled, deliver: j.deliver, lastRunAt: j.lastRunAt, lastStatus: j.lastStatus, lastError: j.lastError, schedule: describeSchedule(j.schedule) }));
+                        const automated = hub.list().filter((m) => m.source === "cron" || m.source === "gateway").map((m) => ({ id: m.id, title: m.title, cwd: m.cwd, source: m.source, sourceName: m.sourceName, updatedAt: m.updatedAt }));
+                        return reply(rpcResult(id, { jobs, sessions: automated }));
+                    }
+                    case "automation.add": {
+                        if (typeof p.name !== "string" || !p.name || typeof p.schedule !== "string" || typeof p.task !== "string" || !p.task) {
+                            return reply(rpcError(id, ERR.PARAMS, "name + schedule + task required"));
+                        }
+                        const sched = parseSchedule(p.schedule, Date.now());
+                        if ("error" in sched)
+                            return reply(rpcError(id, ERR.PARAMS, `bad schedule: ${sched.error}`));
+                        const job = addJob({
+                            name: p.name.slice(0, 60),
+                            schedule: sched,
+                            task: p.task,
+                            mode: ["print", "org", "command"].includes(p.mode) ? p.mode : "print",
+                            cwd: typeof p.cwd === "string" && p.cwd ? p.cwd : opts.cwd,
+                            ...(typeof p.tz === "string" && p.tz ? { tz: p.tz } : {}),
+                            createdAt: Date.now(),
+                        });
+                        return reply(rpcResult(id, { id: job.id, name: job.name, schedule: describeSchedule(job.schedule) }));
+                    }
+                    case "automation.toggle": {
+                        if (typeof p.id !== "string" || typeof p.enabled !== "boolean")
+                            return reply(rpcError(id, ERR.PARAMS, "id + enabled required"));
+                        const jobs = loadJobs();
+                        const job = jobs.find((j) => j.id === p.id);
+                        if (!job)
+                            return reply(rpcError(id, ERR.PARAMS, `no job ${p.id}`));
+                        job.enabled = p.enabled;
+                        saveJobs(jobs);
+                        return reply(rpcResult(id, { id: job.id, enabled: job.enabled }));
+                    }
+                    case "automation.delete": {
+                        if (typeof p.id !== "string")
+                            return reply(rpcError(id, ERR.PARAMS, "id required"));
+                        const jobs = loadJobs();
+                        if (!jobs.some((j) => j.id === p.id))
+                            return reply(rpcError(id, ERR.PARAMS, `no job ${p.id}`));
+                        saveJobs(jobs.filter((j) => j.id !== p.id));
+                        return reply(rpcResult(id, { id: p.id, deleted: true }));
+                    }
                     case "skills.list": {
                         const cwd = typeof p.cwd === "string" && p.cwd ? p.cwd : opts.cwd;
                         return reply(rpcResult(id, { skills: loadSkillIndex(cwd).map((s) => ({ id: s.id, description: s.description, source: s.source })) }));
                     }
+                    case "files.search": {
+                        // fuzzy file lookup for the composer's @-mention autocomplete (codex fuzzyFileSearch).
+                        // Relative POSIX paths; empty query returns the first files as a browse list.
+                        const sess = typeof p.sessionId === "string" ? hub.get(p.sessionId) : undefined;
+                        const cwd = typeof p.cwd === "string" && p.cwd ? p.cwd : (sess?.meta.cwd ?? opts.cwd);
+                        const limit = Math.min(Math.max(Math.trunc(Number(p.limit) || 20), 1), 50);
+                        const all = listProjectFiles(cwd);
+                        const query = typeof p.query === "string" ? p.query : "";
+                        const files = query ? fuzzyRank(query, all, (f) => f).slice(0, limit).map((r) => r.item) : all.slice(0, limit);
+                        return reply(rpcResult(id, { files, cwd }));
+                    }
+                    case "session.context": {
+                        // context-spend breakdown + watermark on demand (codex thread/tokenUsage + /context).
+                        if (typeof p.sessionId !== "string")
+                            return reply(rpcError(id, ERR.PARAMS, "sessionId required"));
+                        const s = hub.get(p.sessionId);
+                        if (!s)
+                            return reply(rpcError(id, ERR.NO_SESSION, `no live session ${p.sessionId}`));
+                        const report = analyzeContext(s.history);
+                        return reply(rpcResult(id, { sessionId: s.meta.id, ...ctxOf(s), total: report.total, rows: report.rows.slice(0, 8) }));
+                    }
+                    case "session.compact": {
+                        // manual compaction (codex thread/compact/start): summarize + replace history, keep working
+                        // notes, restore this-cwd touched files. Busy-guarded like a turn — it IS a provider call.
+                        if (typeof p.sessionId !== "string")
+                            return reply(rpcError(id, ERR.PARAMS, "sessionId required"));
+                        const s = hub.get(p.sessionId);
+                        if (!s)
+                            return reply(rpcError(id, ERR.NO_SESSION, `no live session ${p.sessionId}`));
+                        if (s.busy)
+                            return reply(rpcError(id, ERR.BUSY, "a turn is running — compact after it finishes"));
+                        if (s.history.length < 2)
+                            return reply(rpcError(id, ERR.PARAMS, "nothing to compact yet"));
+                        s.busy = true;
+                        try {
+                            broadcast("event.notice", { sessionId: s.meta.id, text: "✻ Compacting conversation…" });
+                            const summary = await compactSession(s);
+                            if (!summary)
+                                return reply(rpcError(id, ERR.INTERNAL, "compaction failed — try again or /clear"));
+                            broadcast("event.notice", { sessionId: s.meta.id, text: `(compacted — history replaced with a summary; ${s.meta.workingSet?.length ?? 0} notes kept)` });
+                            return reply(rpcResult(id, { sessionId: s.meta.id, ctx: ctxOf(s), notes: s.meta.workingSet?.length ?? 0, history: historyForClient(s.history) }));
+                        }
+                        finally {
+                            s.busy = false;
+                        }
+                    }
+                    case "session.rewind": {
+                        // fork the thread back to before the n-th-most-recent user turn (codex thread/rollback;
+                        // n=1 drops the last exchange). History-only — file edits are not reverted.
+                        if (typeof p.sessionId !== "string" || !Number.isInteger(p.n))
+                            return reply(rpcError(id, ERR.PARAMS, "sessionId + n required"));
+                        const s = hub.get(p.sessionId);
+                        if (!s)
+                            return reply(rpcError(id, ERR.NO_SESSION, `no live session ${p.sessionId}`));
+                        if (s.busy)
+                            return reply(rpcError(id, ERR.BUSY, "a turn is running — rewind after it finishes"));
+                        const next = rewindTo(s.history, p.n);
+                        if (!next)
+                            return reply(rpcError(id, ERR.PARAMS, `n out of range (1..${s.history.filter((m) => m.role === "user").length})`));
+                        s.history.length = 0;
+                        s.history.push(...next);
+                        hub.save(s);
+                        return reply(rpcResult(id, { sessionId: s.meta.id, history: historyForClient(s.history) }));
+                    }
                     default:
                         return reply(rpcError(id, ERR.METHOD, `unknown method ${req.method}`));
                 }

package/dist/serve/sessions.js

@@ -22,6 +22,7 @@ export class SessionHub {
             title: "",
             createdAt: new Date().toISOString(),
             updatedAt: "",
+            source: "interactive", // serve sessions are user-driven (desktop/IDE clients)
         };
         this.store.acquire(meta.id); // fresh id — always ours; registers the single-writer claim
         const s = { meta, history: [], provider: o.provider, approval: o.approval, autoApprove: new Set(), stats: { input: 0, output: 0 }, projectContext: o.projectContext, busy: false, abort: null };
@@ -58,6 +59,36 @@ export class SessionHub {
         }
         this.store.save(s.meta, s.history);
     }
+    /** Rename a session (live or on-disk). Returns false when the id is unknown. */
+    rename(id, title) {
+        const live = this.sessions.get(id);
+        if (live) {
+            live.meta.title = title;
+            this.store.save(live.meta, live.history);
+            return true;
+        }
+        const prior = this.store.load(id);
+        if (!prior)
+            return false;
+        prior.meta.title = title;
+        this.store.save(prior.meta, prior.history);
+        return true;
+    }
+    /** Archive/unarchive (hidden from lists, kept on disk). Returns false when unknown. */
+    setArchived(id, on) {
+        const live = this.sessions.get(id);
+        if (live) {
+            live.meta.archived = on;
+            this.store.save(live.meta, live.history);
+            return true;
+        }
+        const prior = this.store.load(id);
+        if (!prior)
+            return false;
+        prior.meta.archived = on;
+        this.store.save(prior.meta, prior.history);
+        return true;
+    }
     /** 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

@@ -3,6 +3,21 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
 import { randomUUID } from "node:crypto";
+/** Derive the session source from the spawn environment — the gateway subprocess runs with
+ *  HARA_GATEWAY=<platform>, the cron runner with HARA_CRON=1 (+ HARA_CRON_NAME=<job name>). */
+export function sessionSourceFromEnv() {
+    if (process.env.HARA_CRON)
+        return { source: "cron", sourceName: process.env.HARA_CRON_NAME || undefined };
+    if (process.env.HARA_GATEWAY)
+        return { source: "gateway", sourceName: process.env.HARA_GATEWAY };
+    return { source: "interactive" };
+}
+/** Title for a NON-interactive session: "name · MM-DD HH:mm" — the raw prompt never becomes a title. */
+export function automatedTitle(source, sourceName, at = new Date()) {
+    const pad = (n) => String(n).padStart(2, "0");
+    const stamp = `${pad(at.getMonth() + 1)}-${pad(at.getDate())} ${pad(at.getHours())}:${pad(at.getMinutes())}`;
+    return `${sourceName || source} · ${stamp}`;
+}
 function sessionsDir() {
     const d = join(homedir(), ".hara", "sessions");
     mkdirSync(d, { recursive: true });

package/package.json

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