frizz 0.7.8 → 0.8.1

package/README.md

@@ -142,6 +142,9 @@ for a source checkout.
 Options:
   --no-app               print the URL without opening a browser
   --port <port>          request a fixed port for a new workspace server
+  --sandbox              a disposable Frizz to try things in: throwaway home and project, its
+                         own port, deleted when this terminal closes; credentials (gh,
+                         cloudflared, Claude, Codex, the machine's frizz.sh key) are shared
   --link                 print a fresh single-use access link for the running board
   --debug                stream the full event feed to the terminal instead of the compact readout
   -h, --help             show this help
@@ -204,6 +207,8 @@ shows a single-use sign-in link as a QR; press L for a fresh one, or run --link
 
 > Yes. Press **R** in the terminal running Frizz. A short walkthrough sets up one of four ways to reach the board — a name on frizz.sh, a Cloudflare Tunnel you own, Tailscale, or any proxy you run — checks what each needs, prints the commands, and remembers your choice. From then on a plain `npx frizz` serves it; pick **Off** in the same place to go back to loopback only.
 >
+> To try any of this without touching the board you run, launch a second one with `npx frizz --sandbox` — a throwaway home and project on its own port, deleted on ctrl-c.
+>
 > The board stays bound to `127.0.0.1` in every case. Something in front of it — the frizz.sh relay, the tunnel, Tailscale, your proxy — carries the traffic, and Frizz gates the first visit with a single-use sign-in link shown as a QR. Press **L** for a fresh link any time, or `npx frizz --link` from another shell (over SSH, for a headless box). See [Remote access](docs/remote-access.md) for what each option needs.
 
 </details>

package/dist/claude-agent-broker.js

@@ -20353,6 +20353,7 @@ var RealClaudeQueryHandle = class {
     await this.ready();
     this.assertOpen();
     const result = await this.awaitOpenControl(this.sdkQuery.reloadPlugins());
+    this.skillSourcesPromise = null;
     return {
       plugins: Array.isArray(result?.plugins) ? result.plugins.length : 0,
       commands: Array.isArray(result?.commands) ? result.commands.length : 0,
@@ -20371,16 +20372,59 @@ var RealClaudeQueryHandle = class {
   // `supportedCommands()` would re-serve from its cache), and the init frame's `skills` array is the
   // harness's own verdict on which of those are skills rather than built-in commands. The intersection
   // is exactly "what `/name` invokes a skill", with descriptions, and zero frizz-side discovery.
+  //
+  // Where each one CAME FROM is a second question, and claude answers it in exactly one place:
+  // `getContextUsage().skills.skillFrontmatter[].source`. Not in `SlashCommand`, which carries only
+  // {name, description, argumentHint, aliases}. The tempting free alternative — the CLI appends the
+  // source to the description as a parenthetical, " (user)" / " (project)" — was measured and rejected:
+  // it names only those two of the four roots, and the same regex false-positives on descriptions that
+  // legitimately end in a parenthetical (`/deep-research` ends "(dynamic workflow)", `/clear`
+  // "(resumable with /resume)", `/fast` "(Opus 4.8)"). A wrong label is worse than none.
   async listSkills() {
     const initialization = await this.initializationResult();
+    const sources = await this.skillSources();
     const skillNames = new Set(this.initSkills);
     const skills = [];
     for (const command of initialization.commands) {
       if (!command.name || !skillNames.has(command.name)) continue;
-      skills.push({ name: command.name, description: command.description.slice(0, 1024) });
+      const source = sources.get(command.name);
+      skills.push({ name: command.name, description: withoutRedundantSource(command.description, source).slice(0, 1024), source });
     }
     return skills;
   }
+  // The name→source map behind listSkills, fetched ONCE per session and memoized on the promise.
+  //
+  // `getContextUsage()` is a real control round trip that re-counts tokens every time — measured at
+  // 1222ms then 1105ms against claude 2.1.246, so the CLI does not cache it either. Paying that on
+  // every `/` would be felt; paying it once, lazily, on the first `/` a thread ever opens is not, and
+  // the web caches the finished listing per slug on top of that. Deliberately NOT prefetched at init:
+  // most threads never open the menu, and taxing every session start for a menu nobody asked for is
+  // the wrong trade.
+  //
+  // A failure resolves to an EMPTY map rather than rejecting: the source is decoration, and losing it
+  // must never cost the operator the listing itself.
+  skillSourcesPromise = null;
+  skillSources() {
+    this.skillSourcesPromise ??= this.fetchSkillSources().catch(() => /* @__PURE__ */ new Map());
+    return this.skillSourcesPromise;
+  }
+  async fetchSkillSources() {
+    this.assertOpen();
+    const usage = await this.awaitOpenControl(this.sdkQuery.getContextUsage());
+    const rows = boundedArray(usage?.skills?.skillFrontmatter, "contextUsage.skills.skillFrontmatter", 1024);
+    const sources = /* @__PURE__ */ new Map();
+    for (const [index, entry] of rows.entries()) {
+      try {
+        const row = objectValue(entry, `contextUsage.skills.skillFrontmatter[${index}]`);
+        const name = safeText(row.name, `contextUsage.skills.skillFrontmatter[${index}].name`, 512);
+        const source = claudeSkillSource(safeText(row.source, `contextUsage.skills.skillFrontmatter[${index}].source`, 64));
+        if (name && source) sources.set(name, source);
+      } catch {
+        continue;
+      }
+    }
+    return sources;
+  }
   // Unqueue a follow-up the operator has taken back.
   //
   // `cancelAsyncMessage` is present at runtime in @anthropic-ai/claude-agent-sdk 0.3.207 but absent
@@ -20667,11 +20711,14 @@ function startClaudeQuery(executablePath, options) {
       // `user,project,local` reported it applied.
       settingSources: options.settingSources ?? ["user", "project", "local"],
       // The frizz worker environment (see ClaudeQueryStartOptions): load the local cc-worker plugin so a
-      // broker session gets the frizz sub-agent profiles + hooks, mount the MCP servers (frizz +
-      // chrome-devtools), and pre-approve them.
+      // broker session gets the frizz sub-agent profiles + hooks, mount the frizz MCP server, and
+      // pre-approve it. EMPTY is skipped, not passed: since frizz stopped mounting a browser (2026-08-26)
+      // a resolved-nothing worker env is a real state, and `{}`/`[]` are truthy — handing the SDK an
+      // empty allowlist is not the same as handing it none. The project's own `.mcp.json` servers are
+      // loaded by settingSources, independently of this.
       ...options.pluginDir ? { plugins: [{ type: "local", path: options.pluginDir }] } : {},
-      ...options.mcpServers ? { mcpServers: options.mcpServers } : {},
-      ...options.allowedTools ? { allowedTools: options.allowedTools } : {},
+      ...options.mcpServers && Object.keys(options.mcpServers).length > 0 ? { mcpServers: options.mcpServers } : {},
+      ...options.allowedTools?.length ? { allowedTools: options.allowedTools } : {},
       ...options.disallowedTools?.length ? { disallowedTools: [...options.disallowedTools] } : {},
       persistSession: options.persistSession ?? false,
       // Keep Claude's default (preset) system prompt and APPEND the frizz worker contract, the SDK
@@ -21252,6 +21299,19 @@ function mapModelContextWindows(raw) {
   }
   return count === 0 ? void 0 : out;
 }
+var CLAUDE_SOURCE_SUFFIX = { user: " (user)", project: " (project)" };
+function withoutRedundantSource(description, source) {
+  const suffix = source && CLAUDE_SOURCE_SUFFIX[source];
+  if (!suffix || !description.endsWith(suffix)) return description;
+  return description.slice(0, -suffix.length).trimEnd();
+}
+function claudeSkillSource(source) {
+  if (source === "projectSettings") return "project";
+  if (source === "userSettings") return "user";
+  if (source === "built-in") return "builtin";
+  if (source === "plugin") return "plugin";
+  return void 0;
+}
 function mapControlInitialization(raw) {
   const commands = boundedArray(raw.commands, "initialization.commands", 256).map((entry, index) => {
     const command = objectValue(entry, `initialization.commands[${index}]`);