@sigrun/sigrun 0.6.0 → 0.7.0

package/dist/skills/roots.js

@@ -0,0 +1,301 @@
+/**
+ * Task 11: every-root discovery with safe reads.
+ *
+ * `listAllRoots` is the Skills-tab (core/skills view) counterpart to
+ * `discoverSkills`: where `merge()` keeps only the winning skill per
+ * name, this lists EVERY root's skills — losers included — in precedence
+ * order (workspace > learned > user dir > packages in install order),
+ * with shadowing info (`shadowedBy` names the root kind that won), the
+ * hidden flag, and `{error}` rows for skills that fail the safety
+ * checks. The frontmatter parsing is `scanFsRoot`'s own.
+ *
+ * `readSkillFile` / `listSupportFiles` are the ONLY read paths the view
+ * uses: core reads these roots with HOST privileges, so every read
+ * refuses symlinks on EVERY path segment, verifies real-path containment
+ * within the discovery root, allows only SKILL.md or
+ * `references|templates|scripts|assets/<rel>`, and caps reads at
+ * 256 KiB — the same checks the curator store applies
+ * (`assertNoSymlinks` + support-file shape). Without them the view is a
+ * confused deputy: a symlinked SKILL.md would show the user a file the
+ * agent's sandbox could never read. A skill that fails the checks
+ * becomes `{error}` and is never read further.
+ */
+import { lstat, readdir, realpath, readFile, stat } from "node:fs/promises";
+import { join, sep } from "node:path";
+import { validSkillName } from "../curation/names.js";
+import { parseSkillFile } from "./index.js";
+/** The largest file the view will read (SKILL.md or a support file). */
+export const SKILL_READ_CAP_BYTES = 256 * 1024;
+const SKILL_FILE = "SKILL.md";
+const SUPPORT_ROOTS = ["references", "templates", "scripts", "assets"];
+const SYMLINK_REFUSED = "symlinks are not allowed in skill files";
+/**
+ * The file argument's allowed shapes: exactly `SKILL.md`, or a relative
+ * path under `references/`, `templates/`, `scripts/`, or `assets/` with
+ * no empty/`.`/`..` segments, no backslashes, no absolute prefix, no NUL.
+ * Returns the forward-slash segments.
+ */
+function fileSegments(file) {
+    if (file === SKILL_FILE)
+        return [file];
+    if (file.includes("\\") || file.startsWith("/") || file.includes("\0")) {
+        throw new Error("skill file must be SKILL.md or a relative support-file path");
+    }
+    const parts = file.split("/");
+    if (parts.length < 2 ||
+        !SUPPORT_ROOTS.includes(parts[0]) ||
+        parts.some((part) => part === "" || part === "." || part === "..")) {
+        throw new Error("skill file must be SKILL.md or under references/, templates/, scripts/ or assets/");
+    }
+    return parts;
+}
+/**
+ * Refuse symlinks on EVERY segment of `<root>/<segments>` (the curator
+ * store's `assertNoSymlinks` check): a symlink anywhere on the path means
+ * the read target is not what the root contains, so the read is refused
+ * outright. Returns once a segment does not exist — the read itself will
+ * report the absence.
+ */
+async function assertNoSymlinks(root, segments) {
+    let path = root;
+    for (const segment of segments) {
+        path = join(path, segment);
+        try {
+            if ((await lstat(path)).isSymbolicLink())
+                throw new Error(SYMLINK_REFUSED);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+    }
+}
+/**
+ * Real-path containment: after resolving every link, `target` must sit
+ * inside `root`. The belt to `assertNoSymlinks`'s braces — a hardlink-free
+ * lstat walk still cannot see a rename race, and containment catches any
+ * resolution that escaped the anchor regardless of how.
+ */
+async function assertContained(root, target) {
+    const [realRoot, realTarget] = await Promise.all([
+        realpath(root),
+        realpath(target),
+    ]);
+    if (realTarget !== realRoot && !realTarget.startsWith(realRoot + sep)) {
+        throw new Error("skill file escapes its discovery root");
+    }
+}
+/**
+ * The ONLY read path the core/skills view uses. `rootDir` is the
+ * discovery root (the containment anchor), `skill` the skill directory
+ * name inside it, `file` either `SKILL.md` or a support-file path under
+ * `references|templates|scripts|assets`. Symlinks on any segment and any
+ * escape from `rootDir` are refused; reads over 256 KiB are refused.
+ */
+export async function readSkillFile(rootDir, skill, file) {
+    if (!validSkillName(skill))
+        throw new Error(`invalid skill name: ${skill}`);
+    const segments = [skill, ...fileSegments(file)];
+    await assertNoSymlinks(rootDir, segments);
+    const target = join(rootDir, ...segments);
+    await assertContained(rootDir, target);
+    const info = await stat(target);
+    if (info.size > SKILL_READ_CAP_BYTES) {
+        throw new Error(`skill file exceeds the 256 KiB read cap: ${file}`);
+    }
+    const buffer = await readFile(target);
+    if (buffer.byteLength > SKILL_READ_CAP_BYTES) {
+        throw new Error(`skill file exceeds the 256 KiB read cap: ${file}`);
+    }
+    return buffer.toString("utf8");
+}
+/**
+ * Recursively collect relative file paths under `dir`, never following
+ * symlinks: a symlinked entry (file or directory) is skipped, not
+ * traversed — the listing mirrors what `readSkillFile` would serve.
+ */
+async function collectFiles(dir, prefix, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    for (const entry of entries) {
+        if (entry.isSymbolicLink())
+            continue;
+        const relative = `${prefix}/${entry.name}`;
+        if (entry.isDirectory()) {
+            await collectFiles(join(dir, entry.name), relative, out);
+        }
+        else if (entry.isFile()) {
+            out.push(relative);
+        }
+    }
+}
+/**
+ * The support-file listing under one skill, with the same safety posture
+ * as `readSkillFile`: the skill directory must be symlink-free and
+ * contained in `rootDir`, and symlinked entries inside the support roots
+ * are excluded rather than followed. A skill without support files (or
+ * without a directory at all) lists nothing.
+ */
+export async function listSupportFiles(rootDir, skill) {
+    if (!validSkillName(skill))
+        throw new Error(`invalid skill name: ${skill}`);
+    await assertNoSymlinks(rootDir, [skill]);
+    const skillDir = join(rootDir, skill);
+    try {
+        if (!(await lstat(skillDir)).isDirectory())
+            return [];
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    await assertContained(rootDir, skillDir);
+    const out = [];
+    for (const root of SUPPORT_ROOTS) {
+        await collectFiles(join(skillDir, root), root, out);
+    }
+    return out.sort();
+}
+/** The safety check a skill must pass before its SKILL.md is ever read. */
+async function skillSafetyError(rootDir, dirName) {
+    try {
+        await assertNoSymlinks(rootDir, [dirName]);
+        const skillDir = join(rootDir, dirName);
+        if (!(await lstat(skillDir)).isDirectory())
+            return undefined; // not a skill
+        await assertContained(rootDir, skillDir);
+        // SKILL.md itself: present, symlink-free, and inside the root.
+        await assertNoSymlinks(rootDir, [dirName, SKILL_FILE]);
+        await assertContained(rootDir, join(skillDir, SKILL_FILE));
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+/**
+ * List ONE root's skill directories, applying the safety checks before
+ * any read. Entries that are not directories, and directories without a
+ * SKILL.md, are not skills (the v1 rule, unchanged). A symlinked skill
+ * dir or SKILL.md is an error row — named by its directory, never read.
+ * Readable skills parse through `parseSkillFile` (scanFsRoot's own
+ * frontmatter parsing); within one root, duplicate names resolve
+ * first-wins in sorted directory order with a log, exactly like
+ * scanFsRoot.
+ */
+async function scanRootSafely(root) {
+    let entries;
+    try {
+        entries = await readdir(root.rootDir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const names = [...new Set(entries.map((entry) => entry.name))].sort();
+    const skills = [];
+    const byName = new Map();
+    for (const dirName of names) {
+        if (!validSkillName(dirName))
+            continue;
+        const dir = join(root.rootDir, dirName);
+        const base = {
+            root: root.kind,
+            rootDir: root.rootDir,
+            dir,
+            hidden: false,
+            ...(root.packageName === undefined ? {} : { packageName: root.packageName }),
+        };
+        // A symlinked entry (skill dir or SKILL.md inside) is an error row —
+        // never read further, so the target's content leaks nowhere.
+        const safetyError = await skillSafetyError(root.rootDir, dirName);
+        if (safetyError !== undefined) {
+            skills.push({ ...base, name: dirName, description: "", error: safetyError });
+            continue;
+        }
+        let text;
+        try {
+            text = await readSkillFile(root.rootDir, dirName, SKILL_FILE);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                continue; // no SKILL.md — not a skill
+            skills.push({
+                ...base,
+                name: dirName,
+                description: "",
+                error: error instanceof Error ? error.message : String(error),
+            });
+            continue;
+        }
+        const parsed = parseSkillFile(text);
+        if (parsed === undefined || parsed.name === undefined || parsed.description === undefined) {
+            // The v1 skip rule (a malformed SKILL.md is not a skill) holds for
+            // the view too — the row simply does not appear.
+            continue;
+        }
+        const skill = {
+            ...base,
+            name: parsed.name,
+            description: parsed.description,
+            hidden: parsed.disableModelInvocation,
+        };
+        if (!byName.has(skill.name)) {
+            byName.set(skill.name, skill);
+            skills.push(skill);
+        }
+        else {
+            console.warn(`skills: duplicate name "${skill.name}" (${dir} ignored; ${byName.get(skill.name)?.dir} wins)`);
+        }
+    }
+    return skills.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+/**
+ * Every root's skills, losers included, in precedence order: workspace,
+ * learned, user dir, then packages in install order. A name listed by
+ * several roots wins in the FIRST (highest-precedence) root; every
+ * lower-precedence row carries `shadowedBy` naming the winning root
+ * kind. Absent roots are the designed empty case.
+ */
+export async function listAllRoots(opts) {
+    const roots = [];
+    if (opts.workspace !== undefined) {
+        roots.push({ kind: "workspace", rootDir: opts.workspace });
+    }
+    if (opts.learned !== undefined) {
+        roots.push({ kind: "learned", rootDir: opts.learned });
+    }
+    roots.push({ kind: "user dir", rootDir: opts.userDir });
+    for (const pkg of opts.packageRoots) {
+        roots.push({ kind: "package", rootDir: pkg.dir, packageName: pkg.extension });
+    }
+    const out = [];
+    const winners = new Map();
+    for (const root of roots) {
+        for (const skill of await scanRootSafely(root)) {
+            if (skill.error === undefined) {
+                const winner = winners.get(skill.name);
+                if (winner === undefined) {
+                    winners.set(skill.name, skill.root);
+                }
+                else {
+                    out.push({ ...skill, shadowedBy: winner });
+                    continue;
+                }
+            }
+            out.push(skill);
+        }
+    }
+    return out;
+}

package/node_modules/@sigrun/shared/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+
+## [0.7.0] - 2026-11-04
+
+- New `./model-label` subpath: `modelBreadcrumb` collapses every non-leaf path segment of
+  a model id to its first character and prepends the provider (`bifrost` +
+  `chain/acme-flash` → `b/c/acme-flash`).
+- New `./auth` subpath: the one `isProxyOnly` predicate (server, webui, CLI), treating
+  absent/empty method lists as proxy-only (fail safe).
+
+## [0.6.1] - 2026-11-03
+
+- Version pin to the 0.6.1 core family (no shared-source changes beyond the version).
+
 ## [0.6.0] - 2026-11-02
 
 Version-companion release for sigrun 0.6.0 (no shared changes).

package/node_modules/@sigrun/shared/dist/auth.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The auth posture shared by the server, the webui, and the CLI
+ * (polish task 12; proxy-trust spec §5.2/§5.8).
+ *
+ * `isProxyOnly` had THREE private copies (src/server/auth/proxy-only.ts,
+ * webui/src/auth/AuthGate.tsx, src/cli.ts) that could drift: a proxy-only
+ * server mints no redeemable setup code, so every surface must agree on
+ * what "proxy-only" means. One definition lives here now; the server's
+ * own module re-exports it for its existing callers.
+ */
+/**
+ * Whether the configured auth methods are exactly proxy-only: a `proxy`
+ * method with no `token` method. A proxy-only server has no token
+ * callers, so an unvouched setup-code prompt can never be redeemed —
+ * onboarding happens through the proxy in a browser.
+ *
+ * UNKNOWN posture fails safe: an absent/empty method list (the 403
+ * setup_required path carries no methods; a pre-methods server speaks
+ * an older shape) counts as proxy-only — a stranger-facing server whose
+ * auth methods cannot be seen must not invite an unredeemable claim.
+ */
+export declare function isProxyOnly(methods: readonly string[] | undefined): boolean;

package/node_modules/@sigrun/shared/dist/auth.js

@@ -0,0 +1,26 @@
+/**
+ * The auth posture shared by the server, the webui, and the CLI
+ * (polish task 12; proxy-trust spec §5.2/§5.8).
+ *
+ * `isProxyOnly` had THREE private copies (src/server/auth/proxy-only.ts,
+ * webui/src/auth/AuthGate.tsx, src/cli.ts) that could drift: a proxy-only
+ * server mints no redeemable setup code, so every surface must agree on
+ * what "proxy-only" means. One definition lives here now; the server's
+ * own module re-exports it for its existing callers.
+ */
+/**
+ * Whether the configured auth methods are exactly proxy-only: a `proxy`
+ * method with no `token` method. A proxy-only server has no token
+ * callers, so an unvouched setup-code prompt can never be redeemed —
+ * onboarding happens through the proxy in a browser.
+ *
+ * UNKNOWN posture fails safe: an absent/empty method list (the 403
+ * setup_required path carries no methods; a pre-methods server speaks
+ * an older shape) counts as proxy-only — a stranger-facing server whose
+ * auth methods cannot be seen must not invite an unredeemable claim.
+ */
+export function isProxyOnly(methods) {
+    if (methods === undefined || methods.length === 0)
+        return true;
+    return methods.includes("proxy") && !methods.includes("token");
+}

package/node_modules/@sigrun/shared/dist/blocks/index.d.ts

@@ -18,7 +18,7 @@ export { lttb } from "./lttb.js";
 export { formatValue } from "./format.js";
 export { toText } from "./text.js";
 export { canonicalJson, eventKeyWeb, instanceKey } from "./instance.js";
-export type { Action, ActionButton, Bindable, Binding, Block, BlockBase, BulkAction, CalloutBlock, Card, CardBadge, CardMetric, CardMeta, CardStatus, ChartAxisX, ChartAxisY, ChartBlock, ChartSeries, ChartThreshold, ChoiceField, ChoiceOption, CollectionBlock, CollectionColumn, CollectionGroup, CollectionSort, CollectionTime, ColumnChild, ColumnsBlock, Confirm, CoreTarget, DataOp, DataOps, DataUpdate, DateField, DatePreset, DaterangeField, DatetimeField, DetailsBlock, DiffBlock, Field, FieldBase, FieldsBlock, FieldsRow, FileField, Format, FormBlock, GridBlock, GridChild, ImageBlock, ListField, LogBlock, LogLine, LongtextField, MarkdownBlock, MeterBlock, MeterThreshold, NumberField, PageBlock, PageEmpty, Placement, SectionBlock, SecretField, Size, StackBlock, StatBlock, TextField, ToggleField, Tone, Tree, TreeBlock, TreeNode, WidthCondition, } from "./types.js";
+export type { Action, ActionButton, Bindable, Binding, Block, BlockBase, BulkAction, CalloutBlock, Card, CardBadge, CardMetric, CardMeta, CardStatus, ChartAxisX, ChartAxisY, ChartBlock, ChartSeries, ChartThreshold, ChoiceField, ChoiceOption, CollectionBlock, CollectionColumn, CollectionGroup, CollectionSort, CollectionTime, ColumnChild, ColumnsBlock, Confirm, CoreTarget, DataOp, DataOps, DataUpdate, DateField, DatePreset, DaterangeField, DatetimeField, DetailsBlock, DiffBlock, Field, FieldBase, FieldsBlock, FieldsRow, FileField, Format, FormBlock, GridBlock, GridChild, ImageBlock, ListField, LogBlock, LogLine, LongtextField, MarkdownBlock, MeterBlock, MeterThreshold, NumberField, PageBlock, PageEmpty, PageSelection, Placement, SectionBlock, SecretField, Size, StackBlock, StatBlock, TextField, ToggleField, Tone, Tree, TreeBlock, TreeNode, WidthCondition, } from "./types.js";
 export type { IconName } from "./icons.js";
 export type { TextOptions } from "./text.js";
 export type { SurfaceAccess, SurfaceActErr, SurfaceActOk, SurfaceActResult, SurfaceChangedEvent, SurfaceFetch, SurfaceLoad, SurfaceTransport, SurfaceUploadBody, } from "./transport.js";

package/node_modules/@sigrun/shared/dist/blocks/types.d.ts

@@ -108,6 +108,19 @@ export interface PageEmpty {
     title: string;
     hint?: string;
 }
+/**
+ * Server-declared list+detail drill-in (spec §12.3), presentation-only:
+ * on compact widths `selected: false` shows the sidebar list full width
+ * (main hidden); `selected: true` shows main with a back arrow that
+ * navigates with `back` as the params. Wide widths are unchanged —
+ * sidebar and main sit side by side regardless of `selected`. `toText`
+ * ignores it (sidebar then main, as today).
+ */
+export interface PageSelection {
+    readonly selected: boolean;
+    /** The params the compact back arrow navigates to. */
+    readonly back: JsonObject;
+}
 export interface PageBlock extends BlockBase {
     readonly type: "page";
     readonly title: Bindable<string>;
@@ -121,6 +134,8 @@ export interface PageBlock extends BlockBase {
     /** Blocks for a side pane, shown when non-empty. */
     readonly detail?: readonly Block[];
     readonly empty?: PageEmpty;
+    /** Compact-width list+detail drill-in (see {@link PageSelection}). */
+    readonly selection?: PageSelection;
 }
 export interface StackBlock extends BlockBase {
     readonly type: "stack";

package/node_modules/@sigrun/shared/dist/model-label.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The model breadcrumb (polish pass Task 5, spec §5.1): how a client
+ * displays "which model answered this message".
+ *
+ * User ruling: the provider is ALWAYS a breadcrumb segment. Every path
+ * segment except the leaf collapses to its first character, the leaf
+ * stays whole, and the provider joins as its own one-character segment —
+ * `openai` + `gpt-4o-mini` reads `o/gpt-4o-mini`, an old bifrost chain
+ * message (bare `acme-flash`) `b/acme-flash`, a new one (Task 4 restored
+ * the display id, so `chain/acme-flash`) `b/c/acme-flash`. The untruncated
+ * id rides along as `full` for a hover title, so the transcript stays
+ * compact without losing what it abbreviated.
+ *
+ * A message with NO provider shows its plain model name: the archive has
+ * rows recorded before a provider was stamped, and inventing a segment
+ * for them would name a provider nobody recorded.
+ *
+ * Pure module (no imports at all): both clients render this from one
+ * source, so it must never drag in a dependency one of them can't resolve.
+ */
+/**
+ * The two strings a client shows for one message's model: `short` is the
+ * collapsed breadcrumb (the transcript label), `full` the untruncated
+ * `provider/model` id (a hover title).
+ */
+export declare function modelBreadcrumb(provider: string | undefined, model: string): {
+    readonly short: string;
+    readonly full: string;
+};

package/node_modules/@sigrun/shared/dist/model-label.js

@@ -0,0 +1,55 @@
+/**
+ * The model breadcrumb (polish pass Task 5, spec §5.1): how a client
+ * displays "which model answered this message".
+ *
+ * User ruling: the provider is ALWAYS a breadcrumb segment. Every path
+ * segment except the leaf collapses to its first character, the leaf
+ * stays whole, and the provider joins as its own one-character segment —
+ * `openai` + `gpt-4o-mini` reads `o/gpt-4o-mini`, an old bifrost chain
+ * message (bare `acme-flash`) `b/acme-flash`, a new one (Task 4 restored
+ * the display id, so `chain/acme-flash`) `b/c/acme-flash`. The untruncated
+ * id rides along as `full` for a hover title, so the transcript stays
+ * compact without losing what it abbreviated.
+ *
+ * A message with NO provider shows its plain model name: the archive has
+ * rows recorded before a provider was stamped, and inventing a segment
+ * for them would name a provider nobody recorded.
+ *
+ * Pure module (no imports at all): both clients render this from one
+ * source, so it must never drag in a dependency one of them can't resolve.
+ */
+/** The id's path segments, empties dropped (`a//b/` → `["a","b"]`). */
+function pathSegments(id) {
+    return id.split("/").filter((segment) => segment !== "");
+}
+/** The collapsed breadcrumb path: every non-leaf segment's first
+ *  character + the whole leaf. Never called with an empty path. */
+function collapse(path) {
+    const leaf = path[path.length - 1] ?? "";
+    const head = path.slice(0, -1).map((segment) => segment.slice(0, 1));
+    return [...head, leaf].join("/");
+}
+/**
+ * The two strings a client shows for one message's model: `short` is the
+ * collapsed breadcrumb (the transcript label), `full` the untruncated
+ * `provider/model` id (a hover title).
+ */
+export function modelBreadcrumb(provider, model) {
+    if (provider === undefined || provider === "") {
+        return { short: model, full: model };
+    }
+    // The id may already carry its provider (`bifrost/chain/x`): strip the
+    // prefix rather than folding it into a second segment, so the provider
+    // is never named twice.
+    const prefix = `${provider}/`;
+    const rest = model.startsWith(prefix) ? model.slice(prefix.length) : model;
+    const path = pathSegments(rest);
+    if (path.length === 0) {
+        // Nothing but the provider — show it whole, never a trailing slash.
+        return { short: provider.slice(0, 1), full: provider };
+    }
+    return {
+        short: `${provider.slice(0, 1)}/${collapse(path)}`,
+        full: `${provider}/${path.join("/")}`,
+    };
+}

package/node_modules/@sigrun/shared/dist/views.d.ts

@@ -558,6 +558,13 @@ export interface MetaResponse {
             readonly keys: readonly string[];
         }[];
     };
+    /**
+     * The core-owned view surfaces (tabs+skills Task 4) — the same list
+     * `/v1/extensions` serves under `coreViews`; the meta copy exists so
+     * the tab shell's rail never fetches `/v1/extensions` separately.
+     * Absent when no core views attach.
+     */
+    readonly coreViews?: readonly CoreViewInfo[];
     /**
      * Boot-merge collisions (build-and-webui Task 6): name collisions among
      * extension-contributed webui bundles, the provider-catalog merge sink,
@@ -733,6 +740,27 @@ export interface ExtensionSurfaceInfo {
 /** The `GET /v1/extensions` payload (spec §7.7). */
 export interface ExtensionsResponse {
     readonly extensions: readonly ExtensionInfo[];
+    /**
+     * The core-owned view surfaces (tabs+skills Task 4): one row per
+     * `SurfaceDef<"view">` attached under the reserved `core` slug via
+     * `SurfaceService.attachCoreViews` (the Jobs/Skills views). Core views
+     * are NOT `extensions[]` rows — the health dot stays unaffected — so
+     * channels list them from here, ahead of the extension views.
+     */
+    readonly coreViews?: readonly CoreViewInfo[];
+}
+/**
+ * One core-owned view surface on the wire (tabs+skills Task 4): the
+ * id/title/icon the channels' rail/tab registration reads, plus the
+ * declared refresh cadence. Mirrors the view half of
+ * `ExtensionSurfaceInfo`, minus `placement` (core views are always
+ * `view`) and `sharedData` (render-time concern, never list-time).
+ */
+export interface CoreViewInfo {
+    readonly id: string;
+    readonly title: string;
+    readonly icon: string;
+    readonly refreshMs?: number;
 }
 /**
  * The `GET /v1/settings/sections` payload (UI-blocks U4 Task 4, spec

package/node_modules/@sigrun/shared/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/shared",
-	"version": "0.6.0",
+	"version": "0.7.0",
 	"description": "sigrun shared leaf package \u2014 theme tokens, turn/conversation shaping, and the channel wire types (pure leaf, zero dependencies)",
 	"type": "module",
 	"exports": {
@@ -20,6 +20,10 @@
 			"types": "./dist/turns.d.ts",
 			"default": "./dist/turns.js"
 		},
+		"./model-label": {
+			"types": "./dist/model-label.d.ts",
+			"default": "./dist/model-label.js"
+		},
 		"./session-meta": {
 			"types": "./dist/session-meta.d.ts",
 			"default": "./dist/session-meta.js"
@@ -40,6 +44,10 @@
 			"types": "./dist/access.d.ts",
 			"default": "./dist/access.js"
 		},
+		"./auth": {
+			"types": "./dist/auth.d.ts",
+			"default": "./dist/auth.js"
+		},
 		"./settings": {
 			"types": "./dist/settings.d.ts",
 			"default": "./dist/settings.js"

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/sigrun",
-	"version": "0.6.0",
+	"version": "0.7.0",
 	"description": "Self-hosted, multi-user personal-assistant server",
 	"type": "module",
 	"exports": {
@@ -45,12 +45,12 @@
 		"@earendil-works/pi-tui": "^1.3.0",
 		"@fastify/static": "^10.1.7",
 		"@sigrun/ext-codemode": "0.1.2",
-		"@sigrun/ext-curator": "0.1.0",
-		"@sigrun/ext-gateway": "0.1.10",
+		"@sigrun/ext-curator": "0.2.0",
+		"@sigrun/ext-gateway": "0.1.14",
 		"@sigrun/ext-mcp": "0.2.2",
 		"@sigrun/ext-tool-search": "0.1.2",
 		"@sigrun/oauth": "0.1.1",
-		"@sigrun/shared": "0.6.0",
+		"@sigrun/shared": "0.7.0",
 		"croner": "^10.0.1",
 		"fastify": "^5.12.7",
 		"semver": "^7.8.5",
@@ -61,9 +61,9 @@
 		"@sigrun/shared"
 	],
 	"optionalDependencies": {
-		"@sigrun/sandbox-linux-arm64": "0.6.0",
-		"@sigrun/sandbox-linux-x64": "0.6.0",
-		"@sigrun/tui": "0.6.0"
+		"@sigrun/sandbox-linux-arm64": "0.7.0",
+		"@sigrun/sandbox-linux-x64": "0.7.0",
+		"@sigrun/tui": "0.7.0"
 	},
 	"devDependencies": {
 		"@sigrun/memory-markdown": "file:../sigrun-memory-markdown",