sideby 0.13.0 → 0.13.1

package/dist/build.json

@@ -1 +1 @@
-{"id":"20261016T155413-627722"}
+{"id":"20261016T161929-77384f"}

package/dist/src/cli/commands.d.ts

@@ -8,6 +8,7 @@ export interface Io {
     /** The terminal Auto Handoff counts down on (spec §3.17); `process.stdin` when left out. */
     stdin?: HandoffIo['stdin'];
 }
+export declare function setJsonNotice(n: object | null): void;
 export declare function serializeDoctor(r: DoctorReport): {
     status: "issues" | "ok";
     accounts: {

package/dist/src/cli/commands.js

@@ -51,7 +51,12 @@ async function runAccountNow(rt, ref, args, io) {
     }
     return code;
 }
-const json = (io, data) => io.out(JSON.stringify({ schemaVersion: 1, ...data }, null, 2));
+// The `_notice` main.ts works out before a `--json` command (spec §3.23); every JSON output of this run carries it.
+let notice = null;
+export function setJsonNotice(n) {
+    notice = n;
+}
+const json = (io, data) => io.out(JSON.stringify({ schemaVersion: 1, ...data, ...(notice ? { _notice: notice } : {}) }, null, 2));
 function stripFix(f) {
     const { fix: _fix, ...rest } = f;
     return rest;
@@ -1051,11 +1056,41 @@ export async function cmdUpdate(a, io) {
     const asJson = a.flags.has('json');
     const plan = await u.planUpdate(paths, process.env);
     const shown = u.shownPlan(plan);
+    const sk = plan.skill;
+    const skillLine = (s) => s.canRun
+        ? `the sideby skill (for ${s.installed.map((v) => v ?? 'no version').join(', ')}) is updated too:\n  ${s.command}`
+        : `the sideby skill is not updated by sideby: ${s.reason}.\n  ${s.command}`;
     if (!plan.available) {
+        // The CLI is current; an outdated skill is the one thing left to update.
+        if (sk?.outdated && sk.canRun) {
+            if (!a.flags.has('yes')) {
+                if (asJson)
+                    json(io, { ...shown, updated: false });
+                else {
+                    io.out(`${c.green('✓')} sideby ${plan.current} is the latest version.`);
+                    io.out(`\nUpdating ${skillLine(sk)}`);
+                    io.out(c.cyan('\nRun it with `sideby update --yes`.'));
+                }
+                return 10;
+            }
+            if (!asJson)
+                io.out(c.dim(`$ ${sk.command}`));
+            const r = await u.applySkillUpdate(sk, process.env, asJson ? undefined : (t) => process.stderr.write(t));
+            if (asJson)
+                json(io, { ...shown, updated: false, skillUpdated: r?.ok ?? false, message: r?.message ?? '' });
+            else if (r?.ok)
+                io.out(`${c.green('✓')} ${r.message}; agents load it in their next session.`);
+            else
+                io.err(c.red(`✗ ${r?.message}`));
+            return r?.ok ? 0 : 1;
+        }
         if (asJson)
             json(io, { ...shown, updated: false });
-        else
+        else {
             io.out(`${c.green('✓')} sideby ${plan.current} is the latest version.`);
+            if (sk?.outdated)
+                io.out(c.yellow(skillLine(sk)));
+        }
         return 0;
     }
     if (!plan.canRun) {
@@ -1073,6 +1108,8 @@ export async function cmdUpdate(a, io) {
         else {
             io.out(`sideby ${c.bold(plan.latest)} is available (you have ${plan.current}). What changed: ${plan.releaseNotes}`);
             io.out(`\nUpdating runs:\n  ${plan.command}`);
+            if (sk?.outdated)
+                io.out(`Then ${skillLine(sk)}`);
             io.out(c.cyan('\nRun it with `sideby update --yes`.'));
         }
         return 10;
@@ -1091,6 +1128,7 @@ export async function cmdUpdate(a, io) {
             restartedPanel: r.restartedPanel,
             refreshedApp: r.refreshedApp,
             skill: SKILL_INSTALL,
+            ...(r.skillUpdated === undefined ? {} : { skillUpdated: r.skillUpdated }),
             ...(r.ok ? {} : { output: r.output }),
         });
         return r.ok ? 0 : 1;
@@ -1105,7 +1143,14 @@ export async function cmdUpdate(a, io) {
     if (r.refreshedApp)
         io.out('  The desktop app now starts the new version and shows its icon.');
     io.out('  A `sideby ui` running in a terminal and sessions already running keep the old version until you restart them.');
-    io.out(`  If you use the sideby skill, update it too: ${SKILL_INSTALL}`);
+    if (r.skillUpdated)
+        io.out('  The sideby skill was updated too; agents load it in their next session.');
+    else if (r.skillUpdated === false)
+        io.err(c.yellow(`  ${r.skillMessage}`));
+    else if (sk?.outdated)
+        io.out(c.yellow(`  ${skillLine(sk)}`));
+    else if (!sk)
+        io.out(`  If you use the sideby skill, install it with: ${SKILL_INSTALL}`);
     return 0;
 }
 /** The internal `sideby update-check` the CLI starts detached: one Update Check, then Auto Update if it is on. */

package/dist/src/cli/json-schemas.js

@@ -212,6 +212,30 @@ const AppProfile = Type.Object({
 }, {
     description: 'A window of a desktop app that signs in apart from every account (Grok Bot, ADR-0019). Open or create one with `sideby desktop grok-bot:<name>`.',
 });
+/**
+ * On any `--json` output when there is something to mention once the task is done (spec §3.23): a newer sideby in the
+ * cached Update Check, or an installed sideby skill for another version. Off with SIDEBY_NO_UPDATE_NOTIFIER.
+ */
+const Notice = Type.Object({
+    update: Type.Optional(Type.Object({
+        current: Str,
+        latest: Str,
+        command: Type.String({
+            description: 'Run it after the user agrees: it shows the plan and exits 10; then --yes.',
+        }),
+        message: Str,
+    })),
+    skill: Type.Optional(Type.Object({
+        installed: Type.Union([Str, Type.Null()], {
+            description: "The skill's version; null when it has none.",
+        }),
+        current: Str,
+        command: Type.String({
+            description: 'Updates the installed sideby skill (run it after the user agrees).',
+        }),
+        message: Str,
+    })),
+}, { description: 'Not the answer to the task: mention it briefly afterwards and offer to update.' });
 export const OUTPUT_SCHEMAS = {
     list: Type.Object({
         schemaVersion: Version,
@@ -564,7 +588,25 @@ export const OUTPUT_SCHEMAS = {
         refreshedApp: Type.Optional(Type.Boolean({
             description: 'The desktop app (`sideby app install`) was installed and was written again by the new version.',
         })),
-        skill: Type.Optional(Type.String({ description: 'The command that updates the sideby skill; sideby never runs it.' })),
+        skill: Type.Optional(Type.String({ description: 'The command that installs the sideby skill by hand.' })),
+        skillUpdate: Type.Optional(Type.Object({
+            installed: Type.Array(Type.Union([Str, Type.Null()]), {
+                description: 'Versions of the installed sideby skills; null for one without a version.',
+            }),
+            outdated: Type.Boolean({
+                description: 'Some installed skill is for another version than sideby will run.',
+            }),
+            command: Str,
+            canRun: Type.Boolean({
+                description: 'False when sideby leaves the skill alone (see reason): give the user command.',
+            }),
+            reason: Type.Optional(Str),
+        }, {
+            description: 'The installed sideby skill, which the Update brings along; absent when none is installed.',
+        })),
+        skillUpdated: Type.Optional(Type.Boolean({
+            description: 'The skill was updated too (true) or that failed (false); absent when not tried.',
+        })),
         output: Type.Optional(Type.String({ description: 'What the failed install command printed.' })),
     }, { title: 'sideby update --json' }),
     error: Type.Object({
@@ -576,3 +618,8 @@ export const OUTPUT_SCHEMAS = {
     }, { title: 'sideby error --json' }),
     config: ConfigSchema,
 };
+for (const [name, schema] of Object.entries(OUTPUT_SCHEMAS)) {
+    const props = schema.properties;
+    if (name !== 'config' && props)
+        props._notice = Type.Optional(Notice);
+}

package/dist/src/cli/main.js

@@ -249,6 +249,38 @@ function noticeAllowed(cmd, parsed) {
         return false;
     return true;
 }
+/**
+ * Before a `--json` command (spec §3.23): the `_notice` its output carries, from the cached Update Check and the
+ * installed sideby skills, so an agent that reads JSON learns of a newer version too. Starts the next check detached
+ * when the last one is a day old, as afterCommand does on a terminal. Never fails the command.
+ */
+async function jsonNoticeFor() {
+    try {
+        const u = await import('../core/update.js');
+        const { resolvePaths } = await import('../core/paths.js');
+        const { loadConfig } = await import('../core/config.js');
+        const { packageVersion } = await import('../core/version.js');
+        const { installedSkillVersions, SKILL_INSTALL } = await import('../core/skill-check.js');
+        const paths = resolvePaths(process.env);
+        const config = await loadConfig(paths.configFile).catch(() => ({}));
+        const cache = await u.readUpdateCache(paths);
+        const skills = await installedSkillVersions(paths.home);
+        const n = u.jsonNotice(cache, packageVersion(), config, process.env, skills, SKILL_INSTALL);
+        if (!u.checksOff(process.env, config) && u.checkDue(cache, new Date())) {
+            const { spawn } = await import('node:child_process');
+            const child = spawn(process.execPath, [fileURLToPath(import.meta.url), 'update-check'], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.on('error', () => { });
+            child.unref();
+        }
+        return n;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * After a command (spec §3.23): print the Update Notice and the result of an Auto Update, each at most once, and
  * start the next Update Check detached when the last one is a day old. Only on a terminal; never fails the command.
@@ -319,6 +351,7 @@ export async function main(argv) {
     // Only sideby's own options count: arguments after `--` belong to the host.
     const own = args.includes('--') ? args.slice(0, args.indexOf('--')) : args;
     const wantsJson = Boolean(spec?.flags.includes('json')) && own.includes('--json');
+    let notice = null;
     try {
         if (!spec)
             throw new UsageError(`unknown command "${cmd}"; run \`sideby --help\``);
@@ -354,6 +387,10 @@ export async function main(argv) {
             return 0;
         }
         const cmds = await import('./commands.js');
+        if (wantsJson && noticeAllowed(cmd, parsed)) {
+            notice = await jsonNoticeFor();
+            cmds.setJsonNotice(notice);
+        }
         const code = await dispatch(cmd, parsed, io, cmds);
         if (!wantsJson && noticeAllowed(cmd, parsed))
             await afterCommand();
@@ -365,7 +402,7 @@ export async function main(argv) {
         if (wantsJson) {
             const { UserError } = await import('../core/errors.js');
             const code = usage ? 'usage' : err instanceof UserError && err.code ? err.code : 'error';
-            console.log(JSON.stringify({ schemaVersion: 1, error: message, code }, null, 2));
+            console.log(JSON.stringify({ schemaVersion: 1, error: message, code, ...(notice ? { _notice: notice } : {}) }, null, 2));
         }
         else
             console.error(`sideby: ${message}`);

package/dist/src/core/skill-check.d.ts

@@ -2,6 +2,19 @@ import type { FamilyDef, Finding } from '../types.ts';
 export declare const SKILL_INSTALL = "npx skills add Adonis0123/sideby -g";
 /** `metadata.version` from a SKILL.md frontmatter, or null when there is none. */
 export declare function skillVersionOf(text: string): string | null;
+/**
+ * The versions of the sideby skills an agent reads on this machine (`null`: a skill without one): where
+ * `npx skills add -g` puts it (`~/.agents/skills`) and Claude Code's user skills. Read for a `--json` output's
+ * `_notice`, so it looks at two fixed files only; Doctor checks every Family's main directory.
+ */
+export declare function installedSkillVersions(home: string): Promise<(string | null)[]>;
+/** The same skills with the real folder each lives in (for `sideby update`, which may update them). */
+export declare function installedSkills(home: string): Promise<{
+    dir: string;
+    version: string | null;
+}[]>;
+/** The command `sideby update` runs to update an installed sideby skill: it keeps the agents it was installed for. */
+export declare const SKILL_UPDATE: readonly ['npx', '-y', 'skills', 'update', 'sideby', '-g', '-y'];
 /**
  * Checks, for each given Family, the sideby skill its Host reads: `<main>/skills/sideby`, and for Codex also
  * `~/.agents/skills/sideby` (where `npx skills add -g` installs and Codex reads user skills). A file is read

package/dist/src/core/skill-check.js

@@ -2,7 +2,7 @@
 // sideby version teaches commands this CLI may not have, so a version mismatch is a warning with the
 // reinstall command. Not installed is not a problem.
 import { readFile, realpath } from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { mainDirOf } from './accounts.js';
 import { tildify } from './paths.js';
 export const SKILL_INSTALL = 'npx skills add Adonis0123/sideby -g';
@@ -12,6 +12,34 @@ export function skillVersionOf(text) {
     const meta = front && /^metadata:[ \t]*\r?\n((?:[ \t]+.*(?:\r?\n|$))*)/m.exec(front)?.[1];
     return (meta && /^[ \t]+version:[ \t]*['"]?([^'"\s]+)/m.exec(meta)?.[1]) || null;
 }
+/**
+ * The versions of the sideby skills an agent reads on this machine (`null`: a skill without one): where
+ * `npx skills add -g` puts it (`~/.agents/skills`) and Claude Code's user skills. Read for a `--json` output's
+ * `_notice`, so it looks at two fixed files only; Doctor checks every Family's main directory.
+ */
+export async function installedSkillVersions(home) {
+    return (await installedSkills(home)).map((s) => s.version);
+}
+/** The same skills with the real folder each lives in (for `sideby update`, which may update them). */
+export async function installedSkills(home) {
+    const seen = new Set();
+    const out = [];
+    for (const dir of [join(home, '.agents', 'skills'), join(home, '.claude', 'skills')]) {
+        try {
+            const real = await realpath(join(dir, 'sideby', 'SKILL.md'));
+            if (seen.has(real))
+                continue;
+            seen.add(real);
+            out.push({ dir: dirname(real), version: skillVersionOf(await readFile(real, 'utf8')) });
+        }
+        catch {
+            // not installed there
+        }
+    }
+    return out;
+}
+/** The command `sideby update` runs to update an installed sideby skill: it keeps the agents it was installed for. */
+export const SKILL_UPDATE = ['npx', '-y', 'skills', 'update', 'sideby', '-g', '-y'];
 /**
  * Checks, for each given Family, the sideby skill its Host reads: `<main>/skills/sideby`, and for Codex also
  * `~/.agents/skills/sideby` (where `npx skills add -g` installs and Codex reads user skills). A file is read

package/dist/src/core/update.d.ts

@@ -114,6 +114,27 @@ export declare function refreshUpdateCheck(paths: Paths, env: Env): Promise<Upda
 export declare function noticeLine(cache: UpdateCache, current: string, now: Date): string | null;
 /** What the CLI says once about the last Auto Update, or null. */
 export declare function autoUpdateLine(cache: UpdateCache): string | null;
+/** The `_notice` of a `--json` output (spec §3.23): what an agent should mention once its task is done. */
+export interface JsonNotice {
+    update?: {
+        current: string;
+        latest: string;
+        command: string;
+        message: string;
+    };
+    skill?: {
+        installed: string | null;
+        current: string;
+        command: string;
+        message: string;
+    };
+}
+/**
+ * The `_notice` for a `--json` output, from the cached Update Check and the versions of the installed sideby skills
+ * (`null` for one written before skills had a version); null when there is nothing to say or checks are off. It
+ * reads no network: an agent sees what the last check found, as a person sees the Update Notice.
+ */
+export declare function jsonNotice(cache: UpdateCache, current: string, config: UpdateSettings, env: Env, skills: readonly (string | null)[], skillCommand: string): JsonNotice | null;
 /**
  * What the CLI does after a command (spec §3.23), decided from the cache: the lines to print (the Auto Update result,
  * then the Update Notice), the change that records them, and whether to start a background check. The caller prints,
@@ -153,6 +174,8 @@ export interface UpdatePlan {
     command: string;
     canRun: boolean;
     releaseNotes: string;
+    /** The installed sideby skill, which an Update brings along (absent when none is installed). */
+    skill?: SkillUpdatePlan;
 }
 export declare function planFrom(method: InstallMethod, current: string, latest: string, env?: Env): UpdatePlan;
 /** The Install Method as outputs show it: no folder of this machine. */
@@ -174,9 +197,28 @@ export declare function shownPlan(plan: UpdatePlan): {
     command: string;
     canRun: boolean;
     releaseNotes: string;
+    skillUpdate?: SkillUpdatePlan | undefined;
 };
+/** What an Update does to the installed sideby skill (spec §3.23, ADR-0021 amendment 2026-10-17). */
+export interface SkillUpdatePlan {
+    /** Versions of the installed skills (`null`: one without a version). */
+    installed: (string | null)[];
+    /** Some installed skill is for another version than the one sideby will run. */
+    outdated: boolean;
+    command: string;
+    /** False when sideby must not run it; `reason` says why and the user runs `command` where it belongs. */
+    canRun: boolean;
+    reason?: string;
+}
+/** The skill part of an Update toward `target`; null when no sideby skill is installed. Reads two files. */
+export declare function skillUpdatePlan(home: string, target: string): Promise<SkillUpdatePlan | null>;
 /** Asks the registry now (whatever the switches say: the user asked) and returns what an Update would do. */
 export declare function planUpdate(paths: Paths, env: Env): Promise<UpdatePlan>;
+/** Updates the installed sideby skill when the plan says it is outdated and sideby may; null when it did nothing. */
+export declare function applySkillUpdate(plan: SkillUpdatePlan | undefined, env: Env, onOutput?: (text: string) => void): Promise<{
+    ok: boolean;
+    message: string;
+} | null>;
 export interface UpdateResult {
     ok: boolean;
     /** Exit code of the install command; absent when it did not run. */
@@ -189,6 +231,9 @@ export interface UpdateResult {
     refreshedApp: boolean;
     /** Another Update held the lock; nothing ran. */
     busy?: boolean;
+    /** The installed sideby skill was updated too (true), or that failed (false); absent when it was not tried. */
+    skillUpdated?: boolean;
+    skillMessage?: string;
 }
 /**
  * Runs the Update the plan names, then starts a running background Panel again from the new code and, when the

package/dist/src/core/update.js

@@ -6,6 +6,7 @@ import { access, constants, mkdir, open, readdir, readFile, realpath, rm, stat }
 import { dirname, join, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { writeFileAtomic } from './fs-safe.js';
+import { installedSkills, SKILL_INSTALL, SKILL_UPDATE } from './skill-check.js';
 import { localBuild, packageVersion, parseLocalBuild } from './version.js';
 export const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
 export const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
@@ -351,6 +352,32 @@ export function autoUpdateLine(cache) {
         ? `sideby updated itself from ${a.from} to ${a.to} (${RELEASE_NOTES(a.to)})`
         : `sideby could not update itself to ${a.to}: ${a.message}`;
 }
+/**
+ * The `_notice` for a `--json` output, from the cached Update Check and the versions of the installed sideby skills
+ * (`null` for one written before skills had a version); null when there is nothing to say or checks are off. It
+ * reads no network: an agent sees what the last check found, as a person sees the Update Notice.
+ */
+export function jsonNotice(cache, current, config, env, skills, skillCommand) {
+    if (checksOff(env, config))
+        return null;
+    const out = {};
+    if (isNewer(cache.latest, current))
+        out.update = {
+            current,
+            latest: cache.latest,
+            command: 'sideby update',
+            message: `sideby ${cache.latest} is available (this is ${current}); \`sideby update\` shows what it runs and updates after --yes`,
+        };
+    const stale = skills.find((v) => v !== current);
+    if (stale !== undefined)
+        out.skill = {
+            installed: stale,
+            current,
+            command: skillCommand,
+            message: `the installed sideby skill is ${stale ? `for sideby ${stale}` : 'from before skills had a version'}; this sideby is ${current}. \`${skillCommand}\` updates it`,
+        };
+    return out.update || out.skill ? out : null;
+}
 /**
  * What the CLI does after a command (spec §3.23), decided from the cache: the lines to print (the Auto Update result,
  * then the Update Notice), the change that records them, and whether to start a background check. The caller prints,
@@ -532,14 +559,69 @@ export function shownPlan(plan) {
         command: plan.command,
         canRun: plan.canRun,
         releaseNotes: plan.releaseNotes,
+        ...(plan.skill ? { skillUpdate: plan.skill } : {}),
+    };
+}
+/** The folder holding `dir` that is a git work tree, if any: a skill there is managed by that repository. */
+async function gitRootOf(dir) {
+    for (let d = dir;; d = dirname(d)) {
+        try {
+            await stat(join(d, '.git'));
+            return d;
+        }
+        catch {
+            // keep looking up
+        }
+        if (dirname(d) === d)
+            return null;
+    }
+}
+/** The skill part of an Update toward `target`; null when no sideby skill is installed. Reads two files. */
+export async function skillUpdatePlan(home, target) {
+    const skills = await installedSkills(home);
+    if (!skills.length)
+        return null;
+    const installed = skills.map((s) => s.version);
+    const plan = {
+        installed,
+        outdated: installed.some((v) => v !== target),
+        command: SKILL_UPDATE.join(' '),
+        canRun: true,
     };
+    for (const s of skills) {
+        const root = await gitRootOf(s.dir);
+        if (root) {
+            const at = root.startsWith(home) ? `~${root.slice(home.length)}` : root;
+            return {
+                ...plan,
+                command: SKILL_INSTALL,
+                canRun: false,
+                reason: `the skill is in the git repository ${at}, so sideby leaves it alone; update it where that repository comes from`,
+            };
+        }
+    }
+    return plan;
 }
 /** Asks the registry now (whatever the switches say: the user asked) and returns what an Update would do. */
 export async function planUpdate(paths, env) {
     const latest = await fetchLatest(env);
     const at = deps().now().toISOString();
     await updateUpdateCache(paths, { checkedAt: at, triedAt: at, latest }).catch(() => { });
-    return planFrom(await installMethod(env), packageVersion(), latest, env);
+    const plan = planFrom(await installMethod(env), packageVersion(), latest, env);
+    const skill = await skillUpdatePlan(paths.home, plan.available ? latest : plan.current).catch(() => null);
+    return skill ? { ...plan, skill } : plan;
+}
+/** Updates the installed sideby skill when the plan says it is outdated and sideby may; null when it did nothing. */
+export async function applySkillUpdate(plan, env, onOutput) {
+    if (!plan?.outdated || !plan.canRun)
+        return null;
+    const [file, ...args] = SKILL_UPDATE;
+    const r = await deps()
+        .exec(file, args, { env, ...(onOutput ? { onOutput } : {}) })
+        .catch((e) => ({ code: 1, output: e instanceof Error ? e.message : String(e) }));
+    return r.code === 0
+        ? { ok: true, message: 'updated the sideby skill' }
+        : { ok: false, message: `\`${plan.command}\` failed (exit ${r.code}); run it yourself to see why` };
 }
 /**
  * Runs the Update the plan names, then starts a running background Panel again from the new code and, when the
@@ -582,6 +664,8 @@ export async function applyUpdate(paths, plan, env, opts = {}) {
         // the new code writes it again. Only where one is installed; a failure here never fails the Update.
         const installed = await d.appInstalled(paths.home, env).catch(() => false);
         const refreshed = installed && (await d.refreshApp(env).catch(() => false));
+        // The skill teaches agents this version's commands, so it follows the CLI; a failure there keeps the Update.
+        const skill = await applySkillUpdate(plan.skill, env, opts.onOutput);
         return {
             ok: true,
             code: 0,
@@ -589,6 +673,7 @@ export async function applyUpdate(paths, plan, env, opts = {}) {
             message: `updated sideby from ${plan.current} to ${plan.latest}`,
             restartedPanel: restarted,
             refreshedApp: refreshed,
+            ...(skill ? { skillUpdated: skill.ok, skillMessage: skill.message } : {}),
         };
     }
     finally {

package/dist/src/panel/handler.d.ts

@@ -92,8 +92,10 @@ export interface PanelUpdate {
     command?: string;
     canRun: boolean;
     releaseNotes?: string;
-    /** The command that updates the sideby skill, which sideby never runs itself. */
+    /** The command that installs the sideby skill by hand. */
     skill: string;
+    /** The installed sideby skill, which an Update brings along (spec §3.23); absent when none is installed. */
+    skillUpdate?: import('../core/update.ts').SkillUpdatePlan;
 }
 export interface PanelState {
     schemaVersion: 1;

package/dist/src/panel/handler.js

@@ -61,6 +61,9 @@ async function updateState(rt, readOnly) {
         });
     const method = await update.installMethod(rt.env);
     const plan = cache.latest ? update.shownPlan(update.planFrom(method, current, cache.latest, rt.env)) : null;
+    const skillUpdate = await update
+        .skillUpdatePlan(rt.paths.home, plan?.available ? plan.latest : current)
+        .catch(() => null);
     return {
         current,
         ...(cache.latest ? { latest: cache.latest } : {}),
@@ -72,6 +75,7 @@ async function updateState(rt, readOnly) {
         ...(plan ? { command: plan.command, releaseNotes: plan.releaseNotes } : {}),
         canRun: Boolean(plan?.canRun),
         skill: SKILL_INSTALL,
+        ...(skillUpdate ? { skillUpdate } : {}),
     };
 }
 /** The `handoff` map of the Panel state, from the statuses and Quota already read for the page. */
@@ -643,6 +647,7 @@ export function createPanelHandler(opts) {
                     message: r.message,
                     restartedPanel: r.restartedPanel,
                     refreshedApp: r.refreshedApp,
+                    ...(r.skillUpdated === undefined ? {} : { skillUpdated: r.skillUpdated }),
                 };
             },
         },

package/dist/src/panel/i18n.d.ts

@@ -20,6 +20,9 @@ declare const en: {
     'upd.after': string;
     'upd.cannot': string;
     'upd.skill': string;
+    'upd.skillToo': string;
+    'upd.skillDone': string;
+    'upd.skillManaged': string;
     'upd.checksOff': string;
     'upd.latest': string;
     'upd.latestNow': string;

package/dist/src/panel/i18n.js

@@ -21,7 +21,10 @@ const en = {
     'upd.runs': 'Updating runs:',
     'upd.after': 'A background panel restarts by itself and this page reloads. A sideby ui running in a terminal and sessions already running keep the old version until you restart them.',
     'upd.cannot': 'sideby cannot update itself here: {why}. Run this yourself:',
-    'upd.skill': 'If you use the sideby skill, update it too:',
+    'upd.skill': 'If you use the sideby skill, install it with:',
+    'upd.skillToo': 'The sideby skill agents read is updated with it.',
+    'upd.skillDone': 'The sideby skill was updated too; agents load it in their next session.',
+    'upd.skillManaged': 'sideby leaves the skill alone ({why}). Update it with:',
     'upd.checksOff': 'Update checks are off ({why}).',
     'upd.latest': 'This is the newest version',
     'upd.latestNow': 'You have the newest version (checked just now).',
@@ -630,7 +633,10 @@ const zh = {
     'upd.runs': '更新会运行：',
     'upd.after': '后台面板会自己重启，本页随后自动刷新。终端里运行的 sideby ui 和已经在跑的会话要重启后才用新版本。',
     'upd.cannot': '这种安装方式下 sideby 不能自己更新：{why}。请自己运行：',
-    'upd.skill': '如果你装了 sideby skill，也更新一下：',
+    'upd.skill': '如果要用 sideby skill，用这条命令安装：',
+    'upd.skillToo': 'agent 读的 sideby skill 会一起更新。',
+    'upd.skillDone': 'sideby skill 也已更新，agent 下次开会话时生效。',
+    'upd.skillManaged': 'sideby 不会自动更新这个 skill（{why}）。请用这条命令更新：',
     'upd.checksOff': '检查更新已关闭（{why}）。',
     'upd.latest': '已是最新版本',
     'upd.latestNow': '已是最新版本（刚刚检查）。',

package/dist/src/panel/page-script.js

@@ -3198,6 +3198,14 @@ const MAIN = String.raw `
     up.autoBusy = false
     renderUpdate()
   }
+  // The installed sideby skill follows the CLI (spec §3.23): said before the Update, or what to run when sideby may not.
+  function updSkill(u) {
+    const s = u.skillUpdate
+    if (!s) return [h('p', { class: 'small' }, t('upd.skill')), codeCopy(u.skill)]
+    if (!s.outdated) return []
+    if (s.canRun) return [h('p', { class: 'muted small' }, t('upd.skillToo'))]
+    return [h('p', { class: 'small' }, t('upd.skillManaged', { why: s.reason || '' })), codeCopy(s.command)]
+  }
   function renderUpdate() {
     if (!up || dlg.kind !== 'update') return
     const u = updState()
@@ -3211,7 +3219,8 @@ const MAIN = String.raw `
     if (up.done) {
       body.push(h('p', { class: 'note' }, t('upd.done', { v: up.done.latest })))
       body.push(h('p', { class: 'muted small' }, Date.now() > up.waitUntil ? t('upd.restartHint') : [spinner(), ' ', t('upd.reloading')]))
-      body.push(h('p', { class: 'small' }, t('upd.skill')), codeCopy(u.skill))
+      if (up.done.skillUpdated) body.push(h('p', { class: 'small' }, t('upd.skillDone')))
+      else body.push(...updSkill(u))
     } else if (u.available) {
       if (up.changed) body.push(h('p', { class: 'note note-warn' }, t('upd.changed', { v: u.latest })))
       body.push(h('p', null, h('b', null, t('upd.available', { v: u.latest })), ' ',
@@ -3223,7 +3232,7 @@ const MAIN = String.raw `
         body.push(h('p', { class: 'note note-warn' }, t('upd.cannot', { why: u.method.reason || u.method.kind })))
         body.push(codeCopy(u.command))
       }
-      body.push(h('p', { class: 'small' }, t('upd.skill')), codeCopy(u.skill))
+      body.push(...updSkill(u))
     } else if (up.checked && u.latest) {
       body.push(h('p', { class: 'note' }, t('upd.latestNow')))
     } else if (u.checksOff) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sideby",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "Run work, personal and API-key accounts at the same time, without their configs drifting apart.",
   "license": "MIT",
   "author": "Adonis0123 (https://github.com/Adonis0123)",