hop2 0.11.53 → 0.11.54

package/hay/apps/web/src/components/SessionSwitcher.tsx

@@ -28,7 +28,8 @@ import {
   type SessionOriginScope,
   type SwitcherFolder,
   type SwitcherSession,
-  type SwitcherSortMode
+  type SwitcherSortMode,
+  insertAfter
 } from "../utils/switcherModel";
 import { scanKeyboardProtocol } from "../utils/keyboardProtocol";
 import { DigestCard } from "./DigestCard";
@@ -2452,11 +2453,16 @@ export const SessionSwitcher = ({
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ internalName: sessionKey(s), ...(target ? { target } : {}) })
       });
-      const data = await res.json().catch(() => ({} as { error?: string; name?: string; kind?: string; extract?: { turns?: number; bytes?: number } }));
+      const data = await res.json().catch(() => ({} as { error?: string; name?: string; internalName?: string; kind?: string; extract?: { turns?: number; bytes?: number } }));
       if (!res.ok) {
         onNotice(data.error || (target ? "Handoff failed" : "Fork failed"));
         return;
       }
+      // The new session belongs beside its source: the daemon files it in
+      // the same folder; on a hand-arranged wall it takes the next slot.
+      if (typeof data.internalName === "string" && data.internalName) {
+        persistManualOrder(insertAfter(manualOrder, sessionKey(s), data.internalName));
+      }
       if (data.kind === "handoff") {
         const kb = Math.max(1, Math.round((data.extract?.bytes || 0) / 1024));
         onNotice(`${data.name} — ${data.extract?.turns ?? "?"} turns handed off (${kb} KB); it reads them first`);

package/hay/apps/web/src/utils/switcherModel.ts

@@ -266,6 +266,19 @@ const orderManually = (sessions: SwitcherSession[], manualOrder: string[]): Swit
   });
 };
 
+/**
+ * Place `key` right after `afterKey` in a manual order. A source the user
+ * never placed leaves the order alone: both then sort by name at the tail,
+ * where a fork's name already follows its source's.
+ */
+export const insertAfter = (order: string[], afterKey: string, key: string): string[] => {
+  const at = order.indexOf(afterKey);
+  if (at < 0 || afterKey === key) return order;
+  const without = order.filter((k) => k !== key);
+  const i = without.indexOf(afterKey);
+  return [...without.slice(0, i + 1), key, ...without.slice(i + 1)];
+};
+
 /**
  * Split sessions into the user's folders plus everything still loose.
  * Folders belong to MANUAL mode only: Recent is ordered by the machine and

package/hay/apps/web/test/switcherModel.test.ts

@@ -5,7 +5,8 @@ import {
   filterSessionsByOrigin,
   projectKey,
   relativeTime,
-  type SwitcherSession
+  type SwitcherSession,
+  insertAfter
 } from "../src/utils/switcherModel";
 
 const mk = (over: Partial<SwitcherSession> & { name: string }): SwitcherSession => ({
@@ -523,3 +524,15 @@ describe("origin scope vs foldered sessions", () => {
     expect(filterSessionsByOrigin(sessions, "agent").map((s) => s.name)).toContain("mybot");
   });
 });
+
+describe("insertAfter — a fork takes the slot after its source", () => {
+  it("inserts right after a placed source, moving an existing entry", () => {
+    expect(insertAfter(["a", "b", "c"], "a", "x")).toEqual(["a", "x", "b", "c"]);
+    expect(insertAfter(["a", "b", "x"], "a", "x")).toEqual(["a", "x", "b"]);
+  });
+  it("leaves the order alone when the source was never placed, or is itself", () => {
+    const order = ["a", "b"];
+    expect(insertAfter(order, "zzz", "x")).toBe(order);
+    expect(insertAfter(order, "a", "a")).toBe(order);
+  });
+});

package/hop

@@ -11769,18 +11769,24 @@ happens until someone clicks it.
                         saveDefinition: false,
                         command
                     });
+                    // Filed where its source is. The effective config is the
+                    // wall's own truth for the folder (saved, runtime and
+                    // durable layers merged); the durable meta alone missed
+                    // sessions filed before folders were written there.
+                    const folderId = config.folderId || meta?.folderId || null;
                     rememberRuntimeSessionMetadata(forkInternal, {
                         type: 'terminal',
                         displayName: forkName,
                         cwd,
                         createdBy,
-                        folderId: meta?.folderId || undefined
+                        folderId: folderId || undefined
                     });
                     writeClaudeSessionMeta(forkInternal, {
                         internalName: forkInternal,
                         displayName: forkName,
                         cwd,
                         createdBy,
+                        folderId: folderId || undefined,
                         forkedFrom: source,
                         ...(handoff ? { handoffFrom: sourceKind, handoffTo: wantTarget } : {})
                     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.53",
+  "version": "0.11.54",
   "description": "🐰 Hop into your terminal from anywhere. Secure remote shell access with 2FA via Cloudflare Tunnel. Next-gen rewrite with native terminal sharing.",
   "main": "hop",
   "bin": {