sliccy 6.217.0 → 6.218.0

package/README.md

@@ -11,7 +11,7 @@ If this scares, confuses, or excites you, keep reading.
 
 # slicc — Self-Licking Ice Cream Cone
 
-[![58% Vibe_Coded](https://img.shields.io/badge/58%25-Vibe_Coded-ff69b4?style=for-the-badge&logo=claude&logoColor=white)](https://github.com/ai-ecoverse/vibe-coded-badge-action)
+[![59% Vibe_Coded](https://img.shields.io/badge/59%25-Vibe_Coded-ff69b4?style=for-the-badge&logo=claude&logoColor=white)](https://github.com/ai-ecoverse/vibe-coded-badge-action)
 
 [![npm](https://img.shields.io/npm/v/sliccy)](https://www.npmjs.com/package/sliccy)
 
@@ -213,7 +213,7 @@ SLICC shares one core across every runtime ("float"). The browser is not just wh
 
 Once the product makes sense, the ice-cream language is easier to enjoy: it maps to real architecture, not just mascot energy.
 
-- **Cone** — the main agent you interact with. It holds the broad context, owns the overall workflow, and delegates work. You can run several at once: the left rail's action row offers **New cone** (name it; your current chat stays where it is) and **Drop cone** (its chat goes to the Freezer without memory extraction, together with its scoops; the last cone can never be dropped). Cones switch from the tab strip — all cones first, then the scoops of the one you are in. Each cone keeps its own conversation and its own model: the model picker changes the cone you are looking at, switching cones switches the model back, a new cone starts on the model of the cone you created it from, and a scoop keeps the model its cone had when it was spawned. **New chat** / **New chat, fast** / **Discard** archive and clear the cone you are looking at. There is one Freezer for all cones; a thawed chat says which cone it came from. Licks and the first-run welcome stay with the original cone. Each extra cone also gets its own workspace (`/cones/<folder>/workspace`) and memory file, so cones do not overwrite each other's files or interleave each other's memory — what a cone learns is remembered for that cone; `/shared`, `/tmp` and installed skills stay common. **You never talk to a scoop directly**: opening one from the tab strip shows its transcript with no composer — you watch it work, and everything it needs from you (a sudo request, an approval, a nudge when it goes idle) appears in the chat of the cone that owns it. The cone is where you answer, and `feed_scoop` from the cone is the only way to send a scoop input. The iPhone/iPad follower shows the same read-only scoop view. A Cherry embed — SLICC as a garnish inside someone else's page — mirrors the cones its leader has but never offers to create or drop one.
+- **Cone** — the main agent you interact with. It holds the broad context, owns the overall workflow, and delegates work. You can run several at once: the left rail's action row offers **New cone** (name it; your current chat stays where it is) and **Drop cone** (its chat goes to the Freezer without memory extraction, together with its scoops; the last cone can never be dropped). Cones switch from the tab strip — all cones first, then the scoops of the one you are in. Each cone keeps its own conversation and its own model: the model picker changes the cone you are looking at, switching cones switches the model back, a new cone starts on the model of the cone you created it from, and a scoop keeps the model its cone had when it was spawned. **New chat** / **New chat, fast** / **Discard** archive and clear the cone you are looking at. A complete transcript snapshot is attempted for five seconds; working scoops cannot hold the new chat open indefinitely, and the saved chat remains in the Freezer if that extra snapshot is unavailable. There is one Freezer for all cones; a thawed chat says which cone it came from. Licks and the first-run welcome stay with the original cone. Each extra cone also gets its own workspace (`/cones/<folder>/workspace`) and memory file, so cones do not overwrite each other's files or interleave each other's memory — what a cone learns is remembered for that cone; `/shared`, `/tmp` and installed skills stay common. **You never talk to a scoop directly**: opening one from the tab strip shows its transcript with no composer — you watch it work, and everything it needs from you (a sudo request, an approval, a nudge when it goes idle) appears in the chat of the cone that owns it. The cone is where you answer, and `feed_scoop` from the cone is the only way to send a scoop input. The iPhone/iPad follower shows the same read-only scoop view. A Cherry embed — SLICC as a garnish inside someone else's page — mirrors the cones its leader has but never offers to create or drop one.
 - **Scoops** — isolated sub-agents with their own filesystem sandbox, shell, and conversation history.
 - **Licks** — external events that wake an agent up: webhooks, cron jobs, and other signals from the outside world.
 - **Floats** — normal engineers would call it runtimes, but would normal engineers have come up with this?

package/dist/node-server/chrome-launch.d.ts

@@ -186,9 +186,15 @@ export declare const TAB_LIFECYCLE_EXEMPT_SITES: string[];
  *   FreezingFollowsDiscardOptOut) freeze policy.
  *
  * Merges into existing prefs (the profile persists logins across runs) and
- * never throws — a failure here must not block a launch.
+ * never throws — a failure here must not block a launch. Read faults other
+ * than a missing file fail closed: the existing Preferences are left
+ * untouched rather than rewritten from an empty default (#3625).
  */
-export declare function seedChromeProfilePreferences(userDataDir: string): Promise<void>;
+/** Injectable seams for {@link seedChromeProfilePreferences} (tests). */
+export interface SeedChromeProfilePreferencesDeps {
+    readFileImpl?: (path: string) => Promise<string>;
+}
+export declare function seedChromeProfilePreferences(userDataDir: string, deps?: SeedChromeProfilePreferencesDeps): Promise<void>;
 /**
  * Remove Chrome's session-restore snapshot so a relaunch opens ONLY the
  * command-line tab instead of also reopening the previous window's tabs.

package/dist/node-server/chrome-launch.js

@@ -439,14 +439,31 @@ export function findChromeExecutable(options = {}) {
         ? (installedChrome ?? chromeForTesting)
         : (chromeForTesting ?? installedChrome);
 }
-async function readJsonFile(filePath) {
+/**
+ * Read a Chrome profile JSON file for a subsequent write-back.
+ *
+ * - Missing file (`ENOENT`) → `{}` so callers can seed a first-run scaffold.
+ * - Any other read fault (EIO/EACCES/EBUSY/…) or JSON parse / non-object
+ *   result → `null`. Callers MUST fail closed and leave the existing file
+ *   untouched — collapsing those faults to `{}` and rewriting would wipe the
+ *   user's persistent Preferences (#3625).
+ */
+async function readJsonFile(filePath, readFileImpl = (path) => readFile(path, 'utf8')) {
+    let raw;
+    try {
+        raw = await readFileImpl(filePath);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return {};
+        return null;
+    }
     try {
-        const raw = await readFile(filePath, 'utf8');
         const parsed = JSON.parse(raw);
-        return isJsonObject(parsed) ? parsed : {};
+        return isJsonObject(parsed) ? parsed : null;
     }
     catch {
-        return {};
+        return null;
     }
 }
 async function writeJsonFile(filePath, value) {
@@ -494,10 +511,16 @@ export async function ensureQaProfileScaffold(projectRoot) {
         await writeFile(join(profile.userDataDir, 'First Run'), '', 'utf8');
         const localStatePath = join(profile.userDataDir, 'Local State');
         const preferencesPath = join(profile.userDataDir, 'Default', 'Preferences');
-        const localState = seedLocalState(await readJsonFile(localStatePath), definition);
-        const preferences = seedPreferences(await readJsonFile(preferencesPath), definition);
-        await writeJsonFile(localStatePath, localState);
-        await writeJsonFile(preferencesPath, preferences);
+        // Fail closed per file: a transient read fault must not clobber the
+        // existing scaffold (#3625). Missing files still seed from {}.
+        const localStateBase = await readJsonFile(localStatePath);
+        if (localStateBase !== null) {
+            await writeJsonFile(localStatePath, seedLocalState(localStateBase, definition));
+        }
+        const preferencesBase = await readJsonFile(preferencesPath);
+        if (preferencesBase !== null) {
+            await writeJsonFile(preferencesPath, seedPreferences(preferencesBase, definition));
+        }
     }
     return profiles;
 }
@@ -676,27 +699,12 @@ export const TAB_LIFECYCLE_EXEMPT_SITES = [
     hostedLeaderHost.replace(/^www\./, ''),
     'localhost',
 ];
-/**
- * Seed the profile's `Default/Preferences` with tab-lifecycle opt-outs before
- * every launch. The `--disable-features` list in {@link buildChromeLaunchArgs}
- * is the primary defense against Chrome freezing/discarding the backgrounded
- * leader tab, but feature names churn between Chrome versions (Chrome 151
- * renamed the whole pipeline, silently reviving the freeze); these prefs are
- * the version-stable belt:
- *
- * - `tab_freezing_enabled: false` — master pref gating tab freezing;
- * - `performance_tuning.high_efficiency_mode.state: 0` — Memory Saver off;
- * - `performance_tuning.tab_discarding.exceptions` — per-site exemption list
- *   covering the leader origins, honored by both discard and (via Chrome's
- *   FreezingFollowsDiscardOptOut) freeze policy.
- *
- * Merges into existing prefs (the profile persists logins across runs) and
- * never throws — a failure here must not block a launch.
- */
-export async function seedChromeProfilePreferences(userDataDir) {
+export async function seedChromeProfilePreferences(userDataDir, deps = {}) {
     const prefsPath = join(userDataDir, 'Default', 'Preferences');
     try {
-        const prefs = await readJsonFile(prefsPath);
+        const prefs = await readJsonFile(prefsPath, deps.readFileImpl);
+        if (prefs === null)
+            return; // fail closed — do not overwrite durable prefs
         prefs['tab_freezing_enabled'] = false;
         const performanceTuning = ensureObject(prefs, 'performance_tuning');
         const highEfficiencyMode = ensureObject(performanceTuning, 'high_efficiency_mode');