sh3-core 0.15.0 → 0.15.2

package/dist/sh3core-shard/ShellHome.svelte

@@ -10,6 +10,7 @@
   import { listRegisteredApps, launchApp, isAdmin, VERSION } from '../api';
   import ShellTitle from './ShellTitle.svelte';
   import ProjectsSection from '../projects-shard/ProjectsSection.svelte';
+  import LayoutsSection from '../layouts-shard/LayoutsSection.svelte';
   import { sessionState } from '../projects/session-state.svelte';
   import { projectsState } from '../projects-shard/projectsShard.svelte';
   import { shell } from '../shellRuntime.svelte';
@@ -82,6 +83,8 @@
 
   <ProjectsSection />
 
+  <LayoutsSection />
+
   {#if userApps.length > 0}
     <section class="shell-home-section">
       <h2 class="shell-home-section-title">Apps</h2>

package/dist/sh3core-shard/sh3coreShard.svelte.d.ts

@@ -1,2 +1,9 @@
 import type { Shard } from '../api';
+import type { Action } from '../actions/types';
+/**
+ * Build the palette-only float-maximize toggle action. Targets the topmost
+ * float (last entry in `floatManager.list()`); disabled when no floats are
+ * open. See spec docs/superpowers/specs/2026-05-07-float-resize-maximize-design.md.
+ */
+export declare function buildToggleMaximizeAction(): Action;
 export declare const sh3coreShard: Shard;

package/dist/sh3core-shard/sh3coreShard.svelte.js

@@ -31,7 +31,29 @@ import { registeredApps } from '../apps/registry.svelte';
 import { launchApp } from '../apps/lifecycle';
 import { resetActivePresetToDefault } from '../layout/store.svelte';
 import { modalManager } from '../overlays/modal';
+import { floatManager } from '../overlays/float';
 import { registerAppActions } from './appActions';
+/**
+ * Build the palette-only float-maximize toggle action. Targets the topmost
+ * float (last entry in `floatManager.list()`); disabled when no floats are
+ * open. See spec docs/superpowers/specs/2026-05-07-float-resize-maximize-design.md.
+ */
+export function buildToggleMaximizeAction() {
+    return {
+        id: 'sh3.float.toggleMaximize',
+        label: 'Toggle Float Maximize',
+        scope: ['home', 'app'],
+        paletteItem: true,
+        contextItem: false,
+        defaultShortcut: 'Ctrl+Shift+M',
+        disabled: () => floatManager.list().length === 0,
+        run() {
+            const top = floatManager.list().at(-1);
+            if (top)
+                floatManager.toggleMaximize(top.id);
+        },
+    };
+}
 export const sh3coreShard = {
     manifest: {
         id: '__sh3core__',
@@ -61,6 +83,7 @@ export const sh3coreShard = {
                 import('../actions/listeners').then(({ openPalette }) => openPalette());
             },
         });
+        ctx.actions.register(buildToggleMaximizeAction());
         ctx.actions.register({
             id: 'sh3.app.reset-layout',
             label: 'Reset Current Layout',

package/dist/shards/activate-runtime.test.js

@@ -44,8 +44,30 @@ describe('ctx.listVerbs / ctx.runVerb (integration)', () => {
         const list = consumerCtx.listVerbs();
         const a = list.find((v) => v.name === 'host:a');
         const b = list.find((v) => v.name === 'host:b');
-        expect(a).toEqual({ shardId: 'host', name: 'host:a', summary: 'first verb', schema: undefined });
-        expect(b).toEqual({ shardId: 'host', name: 'host:b', summary: 'second verb', schema: undefined });
+        expect(a).toEqual({ shardId: 'host', name: 'host:a', summary: 'first verb', programmatic: true, schema: undefined });
+        expect(b).toEqual({ shardId: 'host', name: 'host:b', summary: 'second verb', programmatic: undefined, schema: undefined });
+    });
+    it('listVerbs({ programmaticOnly: true }) returns only verbs that opted in', async () => {
+        registerShard({
+            manifest: { id: 'host', label: 'Host', version: '0.0.0', views: [] },
+            activate(ctx) {
+                ctx.registerVerb(programmaticVerb('a', 'first verb'));
+                ctx.registerVerb(plainVerb('b', 'second verb'));
+            },
+        });
+        let consumerCtx = null;
+        registerShard({
+            manifest: { id: 'consumer', label: 'C', version: '0.0.0', views: [] },
+            activate(ctx) {
+                consumerCtx = ctx;
+            },
+        });
+        await activateShard('host');
+        await activateShard('consumer');
+        const list = consumerCtx.listVerbs({ programmaticOnly: true });
+        expect(list.find((v) => v.name === 'host:a')).toBeDefined();
+        expect(list.find((v) => v.name === 'host:b')).toBeUndefined();
+        expect(list.every((v) => v.programmatic === true)).toBe(true);
     });
     it('runVerb dispatches a programmatic verb and returns captured scrollback', async () => {
         registerShard({

package/dist/shards/activate.svelte.js

@@ -30,9 +30,11 @@ import { createShardKeysApi } from '../keys/client';
 import { PERMISSION_KEYS_MINT } from '../keys/types';
 import { subscribe } from '../keys/revocation-bus.svelte';
 import { register as contributionsRegister, list as contributionsList, listPoints as contributionsListPoints, onChange as contributionsOnChange, onAnyChange as contributionsOnAnyChange, } from '../contributions';
-import { registerAction } from '../actions/registry';
+import { registerAction, listActions as listActionsFromRegistry } from '../actions/registry';
 import { makeSelectionApi, clearSelectionForShard } from '../actions/selection.svelte';
-import { openContextMenu as shellOpenContextMenu, openPalette as shellOpenPalette } from '../actions/listeners';
+import { openContextMenu as shellOpenContextMenu, openPalette as shellOpenPalette, dispatchActionProgrammatic, } from '../actions/listeners';
+import { listActionsFromEntries } from '../actions/listActive';
+import { getLiveDispatcherState } from '../actions/state.svelte';
 /**
  * Reactive registry of every shard known to the host. Keys are shard ids.
  * Populated once at boot by the glob-discovery loop in main.ts (through
@@ -201,17 +203,29 @@ export async function activateShard(id, opts) {
             openContextMenu(opts) { shellOpenContextMenu(opts); },
             openPalette(opts) { shellOpenPalette(opts); },
         },
-        listVerbs() {
-            return listVerbsWithShard().map(({ verb, shardId }) => ({
+        listVerbs(opts) {
+            const all = listVerbsWithShard();
+            const filtered = (opts === null || opts === void 0 ? void 0 : opts.programmaticOnly)
+                ? all.filter(({ verb }) => verb.programmatic === true)
+                : all;
+            return filtered.map(({ verb, shardId }) => ({
                 shardId,
                 name: verb.name,
                 summary: verb.summary,
+                programmatic: verb.programmatic,
                 schema: verb.schema,
             }));
         },
         runVerb(shardId, name, args, opts) {
             return runVerbProgrammatic(shardId, name, args, opts);
         },
+        listActions(opts) {
+            const all = listActionsFromEntries(listActionsFromRegistry(), getLiveDispatcherState());
+            return (opts === null || opts === void 0 ? void 0 : opts.activeOnly) ? all.filter((a) => a.active) : all;
+        },
+        runAction(actionId, opts) {
+            return dispatchActionProgrammatic(actionId, opts);
+        },
     };
     entry.ctx = ctx;
     // Wire onKeyRevoked hook: subscribe to the revocation bus for this shard.

package/dist/shards/types.d.ts

@@ -7,7 +7,7 @@ import type { Verb, VerbSchema } from '../verbs/types';
 import type { ScrollbackEntry } from '../shell-shard/scrollback.svelte';
 import type { ShardContextKeys } from '../keys/types';
 import type { ContributionsApi } from '../contributions/types';
-import type { ActionsApi } from '../actions/types';
+import type { ActionsApi, ActionDescriptor } from '../actions/types';
 import type { TreeRootRef } from '../layout/types';
 export { PERMISSION_KEYS_MINT, type ShardContextKeys, type ApiKeyPublic, type MintOpts, ScopeEscalationError, ConsentDeniedError } from '../keys/types';
 /**
@@ -255,17 +255,25 @@ export interface ShardContext {
     /**
      * Read-only snapshot of every verb registered across every active shard.
      * Returned entries include the contributing `shardId`, the prefixed
-     * `name`, the verb's `summary`, and (when present) its `schema`.
-     * Order is undefined.
+     * `name`, the verb's `summary`, the `programmatic` flag, and (when
+     * present) its `schema`. Order is undefined.
+     *
+     * Pass `{ programmaticOnly: true }` to restrict the result to verbs that
+     * have opted in via `programmatic: true` — i.e. the verbs that are
+     * actually invocable through `ctx.runVerb(...)`. AI-class shards
+     * typically want this filter so they only surface what they can call.
      *
      * No permission gate — verb names + summaries are already visible via
      * the `help` verb. Diagnostic and AI-class shards (sh3-ai, sh3-diagnostic)
      * use this to enumerate the host's action surface.
      */
-    listVerbs(): Array<{
+    listVerbs(opts?: {
+        programmaticOnly?: boolean;
+    }): Array<{
         shardId: string;
         name: string;
         summary: string;
+        programmatic?: boolean;
         schema?: VerbSchema;
     }>;
     /**
@@ -288,6 +296,38 @@ export interface ShardContext {
         result: unknown;
         scrollback: ScrollbackEntry[];
     }>;
+    /**
+     * Read-only snapshot of every action registered across every shard.
+     * Returns one descriptor per action id; the `active` flag indicates
+     * whether `runAction(id)` would dispatch right now (scope live, not
+     * disabled, has a run handler).
+     *
+     * Pass `{ activeOnly: true }` to filter to currently-dispatchable
+     * actions. AI-class shards typically want this filter.
+     *
+     * No permission gate — actions are already enumerable through the
+     * keyboard / palette / context-menu surfaces.
+     */
+    listActions(opts?: {
+        activeOnly?: boolean;
+    }): ActionDescriptor[];
+    /**
+     * Programmatically dispatch a registered action by id. Synthesizes the
+     * same `ActionDispatchContext` the keyboard/palette/context-menu paths
+     * use, with `invokedVia: 'programmatic'` and `appId / viewId / selection`
+     * sourced from current live state. Resolves after the action's `run`
+     * settles. Rejects on:
+     *   - unknown action id,
+     *   - action exists but is inactive (out-of-scope, disabled, submenu
+     *     parent without `run`),
+     *   - any error thrown by the action's `run`.
+     *
+     * `opts.signal` is stored on the dispatch context for v1 parity with
+     * `runVerb`; today's actions don't read it.
+     */
+    runAction(id: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
 }
 /**
  * A shard module. Shards are the fundamental unit of contribution in SH3.

package/dist/shell-shard/CommandLine.svelte

@@ -0,0 +1,143 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+
+  /**
+   * Single-line command entry widget. The chrome (focus ring, prefix slot,
+   * monospace font, anti-credential-fill attrs) is owned here; consumers
+   * supply the keybinding semantics via `onkeydown`.
+   *
+   * Two behaviors are baked in so every consumer gets them for free:
+   *   - Selection-aware Ctrl+C: when the input has a non-empty selection,
+   *     the keystroke is NOT forwarded to onkeydown — the browser does its
+   *     native copy. This avoids the consumer mapping Ctrl+C to "clear
+   *     draft" or "send SIGINT" eating a copy operation.
+   *   - data-sh3-passthrough-modifiers on the row: the dispatcher's
+   *     "block shortcuts in inputs" rule lets Ctrl/Alt/Meta-bearing
+   *     shortcuts through this widget, so global bindings like Ctrl+K
+   *     fire while the user is typing.
+   */
+  interface Props {
+    value: string;
+    prefix?: Snippet;
+    disabled?: boolean;
+    name?: string;
+    onkeydown?: (e: KeyboardEvent) => void;
+  }
+  let {
+    value = $bindable(''),
+    prefix,
+    disabled = false,
+    name,
+    onkeydown,
+  }: Props = $props();
+
+  let input: HTMLInputElement | null = $state(null);
+
+  function hasSelection(el: HTMLInputElement): boolean {
+    return el.selectionStart !== null
+      && el.selectionEnd !== null
+      && el.selectionStart !== el.selectionEnd;
+  }
+
+  function handleKeyDown(e: KeyboardEvent): void {
+    if ((e.ctrlKey || e.metaKey) && !e.altKey && e.key === 'c'
+        && input && hasSelection(input)) {
+      return;
+    }
+    onkeydown?.(e);
+  }
+
+  $effect(() => {
+    if (!disabled && input) input.focus();
+  });
+</script>
+
+<div
+  class="sh3-cmdline"
+  class:sh3-cmdline--disabled={disabled}
+  data-sh3-passthrough-modifiers
+>
+  {#if prefix}<span class="sh3-cmdline__prefix">{@render prefix()}</span>{/if}
+  <!--
+    Two hidden inputs sit before the real one so Firefox doesn't try to
+    autofill saved credentials into a single visible text field. Source:
+    https://stackoverflow.com/a/29852908 (CC BY-SA 3.0, Bob The Janitor).
+  -->
+  <input type="text" class="sh3-cmdline__decoy" tabindex="-1" aria-hidden="true" />
+  <input type="password" class="sh3-cmdline__decoy" tabindex="-1" aria-hidden="true" />
+  <input
+    bind:this={input}
+    bind:value
+    type="search"
+    {name}
+    {disabled}
+    onkeydown={handleKeyDown}
+    spellcheck="false"
+    autocomplete="off"
+    autocapitalize="off"
+    aria-autocomplete="none"
+    data-1p-ignore
+    data-lpignore="true"
+    class="sh3-cmdline__input"
+  />
+</div>
+
+<style>
+  .sh3-cmdline {
+    display: flex;
+    align-items: baseline;
+    gap: 6px;
+    padding: 4px 8px;
+    border: 1px solid transparent;
+    border-radius: var(--shell-radius);
+    font-family: var(--shell-font-mono, monospace);
+    font-size: var(--shell-font-size, 13px);
+    line-height: 1.4;
+    transition: border-color var(--shell-motion-fast) var(--shell-ease-standard),
+                box-shadow var(--shell-motion-fast) var(--shell-ease-standard);
+  }
+  .sh3-cmdline:focus-within {
+    border-color: var(--shell-input-border-focus);
+    box-shadow: var(--shell-focus-ring);
+  }
+  .sh3-cmdline__prefix {
+    flex-shrink: 0;
+    font: inherit;
+    line-height: inherit;
+    margin: 0;
+  }
+  .sh3-cmdline__input {
+    flex: 1 1 auto;
+    padding: 0;
+    margin: 0;
+    background: transparent;
+    border: 0;
+    outline: 0;
+    color: inherit;
+    font: inherit;
+    line-height: inherit;
+    -webkit-appearance: none;
+    appearance: none;
+  }
+  .sh3-cmdline__input::-webkit-search-cancel-button,
+  .sh3-cmdline__input::-webkit-search-decoration,
+  .sh3-cmdline__input::-webkit-search-results-button,
+  .sh3-cmdline__input::-webkit-search-results-decoration {
+    display: none;
+  }
+  /* The .sh3-cmdline row owns the focus ring; suppress base.css's global
+     input:focus-visible box-shadow so the rings don't double up. */
+  .sh3-cmdline__input:focus,
+  .sh3-cmdline__input:focus-visible {
+    outline: none;
+    box-shadow: none;
+    border: none;
+  }
+  .sh3-cmdline__decoy {
+    display: none;
+  }
+  .sh3-cmdline--disabled .sh3-cmdline__input {
+    opacity: 0.5;
+    cursor: default;
+  }
+</style>

package/dist/shell-shard/CommandLine.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { Snippet } from 'svelte';
+/**
+ * Single-line command entry widget. The chrome (focus ring, prefix slot,
+ * monospace font, anti-credential-fill attrs) is owned here; consumers
+ * supply the keybinding semantics via `onkeydown`.
+ *
+ * Two behaviors are baked in so every consumer gets them for free:
+ *   - Selection-aware Ctrl+C: when the input has a non-empty selection,
+ *     the keystroke is NOT forwarded to onkeydown — the browser does its
+ *     native copy. This avoids the consumer mapping Ctrl+C to "clear
+ *     draft" or "send SIGINT" eating a copy operation.
+ *   - data-sh3-passthrough-modifiers on the row: the dispatcher's
+ *     "block shortcuts in inputs" rule lets Ctrl/Alt/Meta-bearing
+ *     shortcuts through this widget, so global bindings like Ctrl+K
+ *     fire while the user is typing.
+ */
+interface Props {
+    value: string;
+    prefix?: Snippet;
+    disabled?: boolean;
+    name?: string;
+    onkeydown?: (e: KeyboardEvent) => void;
+}
+declare const CommandLine: import("svelte").Component<Props, {}, "value">;
+type CommandLine = ReturnType<typeof CommandLine>;
+export default CommandLine;

package/dist/shell-shard/CommandLine.svelte.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shell-shard/CommandLine.svelte.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, fireEvent } from '@testing-library/svelte';
+import CommandLine from './CommandLine.svelte';
+function realInput(container) {
+    // The widget renders two FF-credential decoy inputs ahead of the real one.
+    return container.querySelector('input.sh3-cmdline__input');
+}
+describe('CommandLine selection-aware Ctrl+C', () => {
+    it('does NOT forward Ctrl+C to onkeydown when input has a non-empty selection', async () => {
+        const onkeydown = vi.fn();
+        const { container } = render(CommandLine, { props: { value: 'hello world', onkeydown } });
+        const inp = realInput(container);
+        inp.focus();
+        inp.setSelectionRange(0, 5); // select "hello"
+        await fireEvent.keyDown(inp, { key: 'c', ctrlKey: true });
+        expect(onkeydown).not.toHaveBeenCalled();
+    });
+    it('forwards Ctrl+C to onkeydown when there is no selection', async () => {
+        const onkeydown = vi.fn();
+        const { container } = render(CommandLine, { props: { value: 'hello', onkeydown } });
+        const inp = realInput(container);
+        inp.focus();
+        inp.setSelectionRange(3, 3); // caret only, no selection
+        await fireEvent.keyDown(inp, { key: 'c', ctrlKey: true });
+        expect(onkeydown).toHaveBeenCalledTimes(1);
+    });
+    it('forwards non-Ctrl+C keys regardless of selection', async () => {
+        const onkeydown = vi.fn();
+        const { container } = render(CommandLine, { props: { value: 'hello', onkeydown } });
+        const inp = realInput(container);
+        inp.focus();
+        inp.setSelectionRange(0, 5);
+        await fireEvent.keyDown(inp, { key: 'k', ctrlKey: true });
+        expect(onkeydown).toHaveBeenCalledTimes(1);
+    });
+});
+describe('CommandLine modifier passthrough attribute', () => {
+    it('stamps data-sh3-passthrough-modifiers so the dispatcher lets modifier shortcuts through', () => {
+        const { container } = render(CommandLine, { props: { value: '' } });
+        const row = container.querySelector('.sh3-cmdline');
+        expect(row.hasAttribute('data-sh3-passthrough-modifiers')).toBe(true);
+    });
+});

package/dist/shell-shard/InputLine.svelte

@@ -1,21 +1,22 @@
 <script lang="ts">
   import type { SessionClient } from './session-client.svelte';
+  import CommandLine from './CommandLine.svelte';
 
   interface Props {
     cwd: string;
+    /** When false, hide the cwd chip in front of the prompt. */
+    showCwd?: boolean;
     locked: boolean;                       // true while a process is running
     history: string[];                     // persisted history, newest last
     session: SessionClient;
     onSubmit: (line: string) => void;      // called with the raw entered line
   }
-  let { cwd, locked, history, session, onSubmit }: Props = $props();
+  let { cwd, showCwd = true, locked, history, session, onSubmit }: Props = $props();
 
   let draft = $state('');
   let historyIndex = $state<number | null>(null);  // null = live draft
   let savedDraft = $state('');                      // restored when user returns from history
 
-  let input: HTMLInputElement | null = $state(null);
-
   function submit() {
     if (locked) return;
     const line = draft;
@@ -74,6 +75,8 @@
       e.preventDefault();
       navHistoryDown();
     } else if (e.ctrlKey && e.key === 'c') {
+      // CommandLine has already filtered this case to no-selection, so the
+      // user is asking to clear the draft, not copy.
       e.preventDefault();
       draft = '';
       historyIndex = null;
@@ -83,52 +86,26 @@
       submit();
     }
   }
-
-  // Re-focus the input when the locked state flips to false
-  $effect(() => {
-    if (!locked && input) {
-      input.focus();
-    }
-  });
 </script>
 
-<div class="shell-input" class:locked>
-  <span class="shell-input-cwd">{cwd}</span>
-  <span class="shell-input-arrow">❯</span>
-  <input
-    bind:this={input}
+<div class="shell-input-row">
+  <CommandLine
     bind:value={draft}
-    type="text"
     disabled={locked}
+    name="shell-cmdline"
     onkeydown={onKeyDown}
-    spellcheck="false"
-    autocomplete="off"
-    autocapitalize="off"
-    class="shell-input-field"
-  />
+  >
+    {#snippet prefix()}
+      {#if showCwd}<span class="shell-input-cwd">{cwd}</span>{/if}
+      <span class="shell-input-arrow">❯</span>
+    {/snippet}
+  </CommandLine>
 </div>
 
 <style>
-  .shell-input {
-    display: flex;
-    gap: 8px;
-    padding: 4px 8px;
+  .shell-input-row {
     border-top: 1px solid var(--shell-border, #333);
-    font-family: var(--shell-font-mono, monospace);
   }
   .shell-input-cwd { color: var(--shell-fg-muted, #888); }
-  .shell-input-arrow { color: var(--shell-accent, #6cf); }
-  .shell-input-field {
-    padding: 0;
-    flex: 1 1 auto;
-    background: transparent;
-    border: 0;
-    outline: 0;
-    color: var(--shell-fg, #ddd);
-    font: inherit;
-  }
-  .shell-input.locked .shell-input-field {
-    opacity: 0.5;
-    cursor: default;
-  }
+  .shell-input-arrow { color: var(--shell-accent, #6cf); margin-left: 6px; }
 </style>

package/dist/shell-shard/InputLine.svelte.d.ts

@@ -1,6 +1,8 @@
 import type { SessionClient } from './session-client.svelte';
 interface Props {
     cwd: string;
+    /** When false, hide the cwd chip in front of the prompt. */
+    showCwd?: boolean;
     locked: boolean;
     history: string[];
     session: SessionClient;

package/dist/shell-shard/ScrollbackView.svelte

@@ -4,11 +4,13 @@
   import PromptEntry from './entries/PromptEntry.svelte';
   import StatusEntry from './entries/StatusEntry.svelte';
   import RichEntry from './entries/RichEntry.svelte';
+  import { lookupRichComponent } from './rich-registry';
 
   interface Props {
     scrollback: Scrollback;
+    showPromptCwd: boolean;
   }
-  let { scrollback }: Props = $props();
+  let { scrollback, showPromptCwd }: Props = $props();
 
   let container: HTMLDivElement | null = $state(null);
   let content: HTMLDivElement | null = $state(null);
@@ -48,11 +50,16 @@
       {#if entry.kind === 'text'}
         <TextEntry stream={entry.stream} chunks={entry.chunks} />
       {:else if entry.kind === 'prompt'}
-        <PromptEntry cwd={entry.cwd} line={entry.line} />
+        <PromptEntry cwd={showPromptCwd ? entry.cwd : ''} line={entry.line} />
       {:else if entry.kind === 'status'}
         <StatusEntry text={entry.text} level={entry.level} />
       {:else if entry.kind === 'rich'}
-        <RichEntry component={entry.component} componentProps={entry.props} />
+        {@const comp = entry.component ?? (entry.componentKey ? lookupRichComponent(entry.componentKey) : null)}
+        {#if comp}
+          <RichEntry component={comp} componentProps={entry.props} />
+        {:else}
+          <StatusEntry text={`<rich entry: ${entry.componentKey ?? 'unknown'} not registered>`} level="info" />
+        {/if}
       {/if}
     {/each}
   </div>

package/dist/shell-shard/ScrollbackView.svelte.d.ts

@@ -1,6 +1,7 @@
 import type { Scrollback } from './scrollback.svelte';
 interface Props {
     scrollback: Scrollback;
+    showPromptCwd: boolean;
 }
 declare const ScrollbackView: import("svelte").Component<Props, {}, "">;
 type ScrollbackView = ReturnType<typeof ScrollbackView>;