@sema-agent/client-core 0.97.0 → 0.98.0

package/dist/hookMatcherVerdict.d.ts

@@ -1,4 +1,5 @@
-export type HookMatcherUnjudgedReason = 'event_out_of_scope' | 'not_a_string' | 'oversize' | 'invalid_pattern' | 'pattern_unsupported' | 'over_budget';
+export type HookMatcherUnjudgedReason = 'event_out_of_scope' | 'not_a_string' | 'oversize' | 'pattern_unsupported' | 'over_budget';
+export type HookMatcherRefusedReason = 'alias_without_canonical' | 'invalid_regex';
 export type HookMatcherVerdict = {
     readonly kind: 'matchesAll';
 } | {
@@ -14,6 +15,10 @@ export type HookMatcherVerdict = {
     readonly reading: 'names' | 'pattern';
     readonly alias: string;
     readonly canonical: string;
+} | {
+    readonly kind: 'refused';
+    readonly reason: 'invalid_regex';
+    readonly reading: 'pattern';
 } | {
     readonly kind: 'unjudged';
     readonly reason: HookMatcherUnjudgedReason;

package/dist/hookMatcherVerdict.js

@@ -12,6 +12,9 @@ function unjudged(reason) {
 function refused(reading, p) {
     return Object.freeze({ kind: 'refused', reason: 'alias_without_canonical', reading, alias: p.alias, canonical: p.canonical });
 }
+function refusedInvalidRegex() {
+    return Object.freeze({ kind: 'refused', reason: 'invalid_regex', reading: 'pattern' });
+}
 function aliasPairs() {
     return Object.entries(HOOK_TOOL_ALIASES).map(([alias, canonical]) => ({ alias, canonical }));
 }
@@ -185,7 +188,7 @@ export function hookMatcherVerdict(event, matcher) {
         return unjudged('oversize');
     const form = SETTINGS_HOOK_MATCHER_FORM(matcher);
     if (form === 'invalid')
-        return unjudged('invalid_pattern');
+        return refusedInvalidRegex();
     const pairs = aliasPairs();
     if (form === 'regex' && matcher !== undefined) {
         const subjects = pairs.flatMap((p) => [p.alias, p.canonical]);
@@ -199,10 +202,10 @@ export function hookMatcherVerdict(event, matcher) {
     const selects = (name) => {
         try {
             const v = SETTINGS_HOOK_MATCHER_SELECTS(matcher, name);
-            return typeof v === 'boolean' ? v : undefined;
+            return v === true ? true : v === false ? false : 'invalid';
         }
         catch {
-            return undefined;
+            return 'threw';
         }
     };
     if (form === 'literal' && selects('') === true)
@@ -211,13 +214,17 @@ export function hookMatcherVerdict(event, matcher) {
     const selected = [];
     for (const p of pairs) {
         const a = selects(p.alias);
-        if (a === undefined)
-            return unjudged('invalid_pattern');
+        if (a === 'invalid')
+            return refusedInvalidRegex();
+        if (a === 'threw')
+            return unjudged('pattern_unsupported');
         if (!a)
             continue;
         const c = selects(p.canonical);
-        if (c === undefined)
-            return unjudged('invalid_pattern');
+        if (c === 'invalid')
+            return refusedInvalidRegex();
+        if (c === 'threw')
+            return unjudged('pattern_unsupported');
         if (!c)
             return refused(reading, p);
         selected.push(p);

package/dist/hooksWireCaps.d.ts

@@ -4,9 +4,9 @@ import type { WireHooksConfig } from './finalVerifyWire.js';
 export { GOAL_STOP_HOOK_WIRE_ENV, isGoalStopHookWireArmed, setWireSessionStopHook, getWireSessionStopHook, } from './goalStopHook.js';
 export type { WireHooksConfig };
 export interface HooksForWireOptions {
-    readonly plan?: HooksWirePlan;
+    readonly plan: HooksWirePlan;
 }
-export declare function hooksForWire(opts?: HooksForWireOptions): WireHooksConfig | undefined;
+export declare function hooksForWire(opts: HooksForWireOptions): WireHooksConfig | undefined;
 export declare function hooksWirePlan(opts?: HooksWirePlanOptions): HooksWirePlan;
 export declare function __resetHooksWireCapsForTests(): void;
 export declare function fleetHookFailureNoticeCapable(baseUrl: string | undefined): boolean;

package/dist/hooksWireCaps.js

@@ -1,8 +1,7 @@
 import { engineCapNestedTrue, engineCapState, engineCapValue } from './engineCapsCache.js';
-import { displayUntrusted } from './displayUntrusted.js';
 import { capForDisplay, collapseLabel } from './fleetTaskDesc.js';
 import { hostLog, hostSettings } from './host.js';
-import { createSettingsHookJudge, decidePluginHooks, dedupeSettingsHookGroups, filterSettingsHookGroups, occupancyOf, settingsHookDropText, } from './pluginHooksWire.js';
+import { createSettingsHookJudge, decidePluginHooks, dedupeSettingsHookGroups, filterSettingsHookGroups, occupancyOf, } from './pluginHooksWire.js';
 import { MAX_HOOK_NOTICE_TEXT_CHARS } from './notifications.js';
 import { goalStopHookMatcher, __resetGoalStopHookForTests } from './goalStopHook.js';
 export { GOAL_STOP_HOOK_WIRE_ENV, isGoalStopHookWireArmed, setWireSessionStopHook, getWireSessionStopHook, } from './goalStopHook.js';
@@ -114,12 +113,6 @@ let warnedNoPluginReader = new WeakSet();
 const NO_PLUGIN_READER_WARNING = 'client-core: the installed settings port does not implement enabledPluginHooks() — ' +
     'plugin hooks are not sent to the engine and are not reported as not running. ' +
     'Implement SettingsPort.enabledPluginHooks() to list the enabled plugins and their hooks.';
-let warnedNoPlanDrops = new WeakMap();
-function noPlanDropWarning(event, reason) {
-    return (`client-core: ${displayUntrusted(event, { credentialUrls: false, credentialWords: false })} hooks from settings are not sent to the engine (${reason}), so they do not run there — ` +
-        `${settingsHookDropText(reason)}. Build the request with hooksForWire({ plan }) from hooksWirePlan() and show ` +
-        'hooksNotRunNotice(plan) to tell the user which hooks will not run.');
-}
 function guardPluginTraversal(run) {
     try {
         return run();
@@ -150,31 +143,61 @@ function readPluginHooks(settings, warnIfAbsent) {
     }
     return { state: 'absent' };
 }
-const NO_PLAN_ENGINE = { ownedByThisShell: null, pluginHooksCapable: null, hooksCapable: null };
-export function hooksForWire(opts = {}) {
-    const given = opts?.plan;
-    if (isHooksWirePlan(given))
-        return given.wire;
-    if (given !== undefined && given !== null) {
-        hostLog('debug', 'hooksForWire: opts.plan is not a plan from hooksWirePlan() — treated as absent (settings hooks only)');
-    }
-    if (isHooksWirePlan(opts))
-        return opts.wire;
-    return buildHooksWirePlan(NO_PLAN_ENGINE, () => false, false, true).wire;
+function usageError(tail) {
+    return new TypeError(`hooksForWire: pass { plan } with the plan returned by hooksWirePlan() for this turn — ${tail}`);
+}
+function hostValueShape(v) {
+    try {
+        if (v === undefined)
+            return 'nothing';
+        if (v === null)
+            return 'null';
+        if (Array.isArray(v))
+            return 'an array';
+        return typeof v === 'object' ? 'an object' : `a ${typeof v}`;
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+export function hooksForWire(opts) {
+    if (typeof opts !== 'object' || opts === null)
+        throw usageError(`got ${hostValueShape(opts)}.`);
+    let given;
+    try {
+        given = opts.plan;
+    }
+    catch {
+        throw usageError(`reading opts.plan threw.`);
+    }
+    const shape = planShapeOf(given);
+    if (shape === 'plan') {
+        try {
+            return given.wire;
+        }
+        catch {
+            throw usageError(`reading the plan's wire threw.`);
+        }
+    }
+    if (shape === 'threw')
+        throw usageError(`opts.plan could not be read as a plan.`);
+    if (given === undefined && planShapeOf(opts) === 'plan')
+        throw usageError(`the plan itself was passed; wrap it as { plan }.`);
+    throw usageError(`opts.plan is ${given === undefined ? 'missing' : `not such a plan (got ${hostValueShape(given)})`}.`);
 }
-function isHooksWirePlan(v) {
+function planShapeOf(v) {
     try {
         if (typeof v !== 'object' || v === null || Array.isArray(v))
-            return false;
+            return 'not';
         const o = v;
         for (const k of PLAN_KEYS)
             if (!Object.hasOwn(o, k) && k !== 'settingsVerdicts' && k !== 'settingsExcluded')
-                return false;
+                return 'not';
         const reader = o.pluginReader;
         const engineFacts = o.engine;
         const wire = o.wire;
         const arrayOrAbsent = (k) => !Object.hasOwn(o, k) || Array.isArray(o[k]);
-        return (Array.isArray(o.verdicts) &&
+        return Array.isArray(o.verdicts) &&
             Array.isArray(o.excluded) &&
             Array.isArray(o.settingsDropped) &&
             arrayOrAbsent('settingsVerdicts') &&
@@ -182,11 +205,12 @@ function isHooksWirePlan(v) {
             (reader === 'present' || reader === 'absent' || reader === 'failed') &&
             typeof engineFacts === 'object' &&
             engineFacts !== null &&
-            (wire === undefined || (typeof wire === 'object' && wire !== null && !Array.isArray(wire))));
+            (wire === undefined || (typeof wire === 'object' && wire !== null && !Array.isArray(wire)))
+            ? 'plan'
+            : 'not';
     }
-    catch (err) {
-        hostLog('debug', `hooksForWire: a value offered as a plan threw while being read — treated as not a plan: ${String(err)}`);
-        return false;
+    catch {
+        return 'threw';
     }
 }
 const PLAN_KEYS = ['engine', 'pluginReader', 'verdicts', 'excluded', 'settingsDropped', 'settingsVerdicts', 'settingsExcluded', 'wire'];
@@ -217,7 +241,7 @@ export function hooksWirePlan(opts = {}) {
         const types = typesByEvent.get(event);
         return types === undefined || (typeof type === 'string' && types.has(type));
     };
-    return buildHooksWirePlan(engine, shellRuns, true, promptAuthoredByUserOf(o));
+    return buildHooksWirePlan(engine, shellRuns, promptAuthoredByUserOf(o));
 }
 function taskHooksCapability(baseUrl) {
     const v = engineCapValue(baseUrl, 'taskSettings');
@@ -268,16 +292,14 @@ function promptAuthoredByUserOf(o) {
     }
     return true;
 }
-function buildHooksWirePlan(engine, shellRuns, withPlugins, promptAuthoredByUser) {
+function buildHooksWirePlan(engine, shellRuns, promptAuthoredByUser) {
     const settingsDropped = [];
     const settingsVerdicts = [];
     const settingsExcluded = [];
-    const judge = withPlugins ? createSettingsHookJudge(engine, shellRuns, promptAuthoredByUser) : undefined;
+    const judge = createSettingsHookJudge(engine, shellRuns, promptAuthoredByUser);
     let settingsStripped = 0;
     const planOf = (pluginReader, wire, verdicts = [], excluded = []) => ({ engine, pluginReader, verdicts, excluded, settingsDropped, settingsVerdicts, settingsExcluded, wire });
     const closedPlan = (settings, reason) => {
-        if (!withPlugins)
-            return planOf('absent', undefined);
         const read = readPluginHooks(settings, false);
         if (read.reading === undefined)
             return planOf(read.state, undefined);
@@ -334,10 +356,10 @@ function buildHooksWirePlan(engine, shellRuns, withPlugins, promptAuthoredByUser
         hostLog('debug', 'hooksWireCaps: disableAllHooks (merged, non-managed) — only policySettings hooks projected to the engine');
     }
     const managedOnly = managedByPolicy || disabledByNonManaged;
-    const read = withPlugins ? readPluginHooks(settings, true) : undefined;
+    const read = readPluginHooks(settings, true);
     let oldStartupBit;
     let pluginDataThrew = false;
-    if (read?.reading !== undefined) {
+    if (read.reading !== undefined) {
         const reading = read.reading;
         const bit = guardPluginTraversal(() => reading.suppressedByStartupMode === true);
         if (bit === undefined)
@@ -362,7 +384,7 @@ function buildHooksWirePlan(engine, shellRuns, withPlugins, promptAuthoredByUser
         for (const [event, groups] of Object.entries(hooks)) {
             if (!Array.isArray(groups) || groups.length === 0)
                 continue;
-            const kept = filterSettingsHookGroups(source, event, groups, engine.pluginHooksCapable === true, (type) => shellRuns(event, type), !withPlugins, judge);
+            const kept = filterSettingsHookGroups(source, event, groups, engine.pluginHooksCapable === true, (type) => shellRuns(event, type), judge);
             settingsDropped.push(...kept.drops);
             settingsVerdicts.push(...kept.verdicts);
             settingsExcluded.push(...kept.excluded);
@@ -401,25 +423,8 @@ function buildHooksWirePlan(engine, shellRuns, withPlugins, promptAuthoredByUser
             'stripped before sending (plugin context is only minted for entries from the plugin reader)');
     }
     const wireOf = () => (Object.keys(merged).length > 0 ? merged : undefined);
-    if (!withPlugins) {
-        let seen = warnedNoPlanDrops.get(settings);
-        for (const d of settingsDropped) {
-            if (!d.notRun)
-                continue;
-            const key = `${d.event}\u0000${d.reason}`;
-            if (seen?.has(key) === true)
-                continue;
-            if (seen === undefined) {
-                seen = new Set();
-                warnedNoPlanDrops.set(settings, seen);
-            }
-            seen.add(key);
-            hostLog('warn', noPlanDropWarning(d.event, d.reason));
-        }
-        return planOf('absent', wireOf());
-    }
-    if (read?.reading === undefined)
-        return planOf(read?.state ?? 'absent', wireOf());
+    if (read.reading === undefined)
+        return planOf(read.state, wireOf());
     if (pluginDataThrew)
         return planOf('failed', wireOf());
     const reading = read.reading;
@@ -451,7 +456,6 @@ export function __resetHooksWireCapsForTests() {
     __resetGoalStopHookForTests();
     warnedNoMergedReader = new WeakSet();
     warnedNoPluginReader = new WeakSet();
-    warnedNoPlanDrops = new WeakMap();
 }
 export function fleetHookFailureNoticeCapable(baseUrl) {
     return engineCapNestedTrue(baseUrl, 'fleet', 'hookFailureNotice');

package/dist/i18n/messages.en.d.ts

@@ -0,0 +1,121 @@
+declare const EN: {
+    'onboard.chrome.step': string;
+    'onboard.chrome.quitHint': string;
+    'onboard.chrome.quitArmed': string;
+    'onboard.station.language': string;
+    'onboard.station.theme': string;
+    'onboard.station.model': string;
+    'onboard.station.tiers': string;
+    'onboard.station.websearch': string;
+    'onboard.station.memory': string;
+    'onboard.station.mcp': string;
+    'onboard.station.skills': string;
+    'onboard.station.plugins': string;
+    'onboard.blurb.model': string;
+    'onboard.blurb.tiers': string;
+    'onboard.blurb.mcp': string;
+    'onboard.blurb.skills': string;
+    'onboard.blurb.plugins': string;
+    'onboard.welcome.title': string;
+    'onboard.welcome.tagline': string;
+    'onboard.theme.hint': string;
+    'onboard.theme.hintFirst': string;
+    'onboard.language.title': string;
+    'onboard.language.blurb': string;
+    'onboard.language.hint': string;
+    'onboard.language.detected': string;
+    'onboard.language.savedPreference': string;
+    'onboard.language.sourceDefault': string;
+    'onboard.memory.title': string;
+    'onboard.memory.on': string;
+    'onboard.memory.off': string;
+    'onboard.memory.current': string;
+    'onboard.memory.blurb': string;
+    'onboard.memory.hint': string;
+    'onboard.language.saveFailed': string;
+    'config.header.subtitle': string;
+    'config.menu.hint': string;
+    'config.domain.model': string;
+    'config.domain.tiers': string;
+    'config.domain.mcp': string;
+    'config.domain.skills': string;
+    'config.domain.plugins': string;
+    'config.domain.marketplaces': string;
+    'config.domain.engine': string;
+    'config.domain.language': string;
+    'config.language.title': string;
+    'config.language.intro': string;
+    'config.language.hint': string;
+    'config.language.saved': string;
+    'config.language.saveFailed': string;
+    'config.language.sourceSaved': string;
+    'config.language.sourceSystem': string;
+    'config.language.sourceDefault': string;
+    'doctor.section.diagnostics': string;
+    'doctor.section.version': string;
+    'doctor.section.settings': string;
+    'doctor.section.updates': string;
+    'doctor.section.engine': string;
+    'doctor.section.axes': string;
+    'doctor.common.unknown': string;
+    'doctor.version.line': string;
+    'doctor.version.enginePinned': string;
+    'doctor.version.ccBase': string;
+    'doctor.version.packageManager': string;
+    'doctor.version.path': string;
+    'doctor.version.invoked': string;
+    'doctor.version.diagnosticUnavailable': string;
+    'doctor.row.warn': string;
+    'doctor.row.fix': string;
+    'doctor.row.learnMore': string;
+    'doctor.settings.ok': string;
+    'doctor.settings.fileUnspecified': string;
+    'doctor.settings.checkUnavailable': string;
+    'doctor.updates.devChannel': string;
+    'doctor.updates.npmChannel': string;
+    'doctor.updates.installed': string;
+    'doctor.updates.latest': string;
+    'doctor.updates.upToDateSuffix': string;
+    'doctor.updates.updateAvailable': string;
+    'doctor.updates.fetchFailed': string;
+    'doctor.updates.checkUnavailable': string;
+    'doctor.updates.localChannel': string;
+    'doctor.updates.unknownChannel': string;
+    'doctor.updates.aheadSuffix': string;
+    'doctor.updates.updateAvailableLocal': string;
+    'doctor.updates.autoOn': string;
+    'doctor.updates.autoOff': string;
+    'doctor.updates.lastAutoFailure': string;
+    'doctor.diag.managedSettingsInvalid.issue': string;
+    'doctor.diag.managedSettingsInvalid.fix': string;
+    'doctor.diag.managedSettingsUnknown.issue': string;
+    'doctor.diag.managedSettingsUnknown.fix': string;
+    'doctor.diag.pathWindows.issue': string;
+    'doctor.diag.pathWindows.fix': string;
+    'doctor.diag.pathUnix.issue': string;
+    'doctor.diag.pathUnix.fix': string;
+    'doctor.diag.unknownShellConfig': string;
+    'doctor.diag.localMismatch.issue': string;
+    'doctor.diag.nativeMismatch.issue': string;
+    'doctor.diag.considerNative.fix': string;
+    'doctor.diag.runSemaInstall.fix': string;
+    'doctor.diag.localExists.issue': string;
+    'doctor.diag.localNotAccessible.issue': string;
+    'doctor.diag.localNotAccessibleAlias.fix': string;
+    'doctor.diag.localNotAccessibleNoAlias.fix': string;
+    'doctor.diag.linuxGlob.issue': string;
+    'doctor.diag.linuxGlob.fix': string;
+    'doctor.diag.leftoverGlobal.issue': string;
+    'doctor.diag.orphanGlobal.issue': string;
+    'doctor.diag.leftoverLocal.issue': string;
+    'doctor.diag.runCmd.fix': string;
+    'doctor.diag.insufficientPermissions.issue': string;
+    'doctor.diag.insufficientPermissions.fix': string;
+    'model.subagent.tiersInert': string;
+    'model.subagent.chainUnbound': string;
+    'model.subagent.bindingNotInCatalog': string;
+    'model.subagent.ambiguous': string;
+};
+export declare const EN_MESSAGES: Readonly<typeof EN>;
+export type MessageKey = keyof typeof EN;
+export {};

package/dist/i18n/messages.en.js

@@ -0,0 +1,119 @@
+const EN = {
+    'onboard.chrome.step': 'Step {step} of {total} · {label}',
+    'onboard.chrome.quitHint': '(ctrl+C twice to quit)',
+    'onboard.chrome.quitArmed': 'press again to quit setup',
+    'onboard.station.language': 'Language',
+    'onboard.station.theme': 'Theme',
+    'onboard.station.model': 'Model',
+    'onboard.station.tiers': 'Model tiers',
+    'onboard.station.websearch': 'Web search',
+    'onboard.station.memory': 'Memory',
+    'onboard.station.mcp': 'MCP servers',
+    'onboard.station.skills': 'Skills',
+    'onboard.station.plugins': 'Plugins',
+    'onboard.blurb.model': 'Add the model(s) sema should use — you can change this anytime with `sema config model`.',
+    'onboard.blurb.tiers': 'Bind your models to tiers (pro drives everyday work, flash the cheap volume) and pick the default tier — you can change this anytime with `sema config tiers`.',
+    'onboard.blurb.mcp': 'Import MCP servers — you can change this anytime with `sema config mcp`.',
+    'onboard.blurb.skills': 'Import skills — you can change this anytime with `sema config skills`.',
+    'onboard.blurb.plugins': 'Install plugins — you can change this anytime with `sema config plugins`.',
+    'onboard.welcome.title': '✻ Welcome to Sema',
+    'onboard.welcome.tagline': 'One shell, your whole fleet — local engine autostart, multi-agent orchestration, cloud when you want it.',
+    'onboard.theme.hint': 'enter to continue · esc to go back · q twice to quit',
+    'onboard.theme.hintFirst': 'enter to continue · q/esc twice to quit',
+    'onboard.language.title': 'Choose your language',
+    'onboard.language.blurb': "sema's own screens (setup, `sema config`, `sema doctor`) use this language — you can change it anytime with `sema config language`.",
+    'onboard.language.hint': '↑↓ to select · enter to continue',
+    'onboard.language.detected': 'detected from your system',
+    'onboard.language.savedPreference': 'your saved preference',
+    'onboard.language.sourceDefault': 'default — no saved choice and no system language found',
+    'onboard.memory.title': 'Should sema remember things across sessions?',
+    'onboard.memory.on': 'On — remember useful facts and preferences',
+    'onboard.memory.off': 'Off — nothing is saved, recalled or added to requests',
+    'onboard.memory.current': 'current setting',
+    'onboard.memory.blurb': 'Auto-memory is kept by the engine and shared by all your projects. You can change this anytime with /memory or `sema config`.',
+    'onboard.memory.hint': '↑↓ to select · enter to continue',
+    'onboard.language.saveFailed': "language   picked {language}, but it could not be saved ({error}) — this session only",
+    'config.header.subtitle': 'Settings',
+    'config.menu.hint': '↑↓ to select · enter to open · esc to exit',
+    'config.domain.model': 'Model',
+    'config.domain.tiers': 'Model tiers',
+    'config.domain.mcp': 'MCP servers',
+    'config.domain.skills': 'Skills',
+    'config.domain.plugins': 'Plugins',
+    'config.domain.marketplaces': 'Marketplaces',
+    'config.domain.engine': 'Engine',
+    'config.domain.language': 'Language',
+    'config.language.title': 'Language',
+    'config.language.intro': "The language sema's own screens use. The model's replies follow your prompt and the /config `Language` setting, not this one.",
+    'config.language.hint': '↑↓ to select · enter to save · esc to go back',
+    'config.language.saved': 'Language set to {language}.',
+    'config.language.saveFailed': 'Could not save the language: {error}',
+    'config.language.sourceSaved': 'saved',
+    'config.language.sourceSystem': 'from system locale',
+    'config.language.sourceDefault': 'default (no saved choice and no system language found)',
+    'doctor.section.diagnostics': 'Diagnostics',
+    'doctor.section.version': 'Version',
+    'doctor.section.settings': 'Settings',
+    'doctor.section.updates': 'Updates',
+    'doctor.section.engine': 'Engine',
+    'doctor.section.axes': 'Axes',
+    'doctor.common.unknown': 'unknown',
+    'doctor.version.line': '└ Version: sema {version}',
+    'doctor.version.enginePinned': '└ Engine (pinned): {version}',
+    'doctor.version.ccBase': '└ CC-compatible base: {version} · running as {installationType}',
+    'doctor.version.packageManager': '└ Package manager: {packageManager}',
+    'doctor.version.path': '└ Path: {path}',
+    'doctor.version.invoked': '└ Invoked: {binary}',
+    'doctor.version.diagnosticUnavailable': '└ WARN installation diagnostic unavailable',
+    'doctor.row.warn': '└ WARN {issue}',
+    'doctor.row.fix': '    fix: {fix}',
+    'doctor.row.learnMore': '    learn more: {link}',
+    'doctor.settings.ok': '└ Settings files: OK no problems reported',
+    'doctor.settings.fileUnspecified': '(file not specified)',
+    'doctor.settings.checkUnavailable': '└ WARN settings check unavailable',
+    'doctor.updates.devChannel': '└ Channel: dev workdir (local dist build — not an npm install)',
+    'doctor.updates.npmChannel': '└ Channel: npm registry (@sema-agent/cli)',
+    'doctor.updates.installed': '└ Installed: {version}',
+    'doctor.updates.latest': '└ Latest: {version}',
+    'doctor.updates.upToDateSuffix': ' (up to date)',
+    'doctor.updates.updateAvailable': '└ Update available — run `sema update`',
+    'doctor.updates.fetchFailed': '└ Failed to fetch latest from the sema registry',
+    'doctor.updates.checkUnavailable': '└ WARN update check unavailable',
+    'doctor.updates.localChannel': "└ Channel: npm package installed in {path} (not npm's global install)",
+    'doctor.updates.unknownChannel': '└ Channel: npm package (install location unconfirmed: {why})',
+    'doctor.updates.aheadSuffix': ' (installed version is newer — nothing to update)',
+    'doctor.updates.updateAvailableLocal': "└ Update available — update it where it was installed (sema update only updates npm's global install)",
+    'doctor.updates.autoOn': '└ Auto-updates: enabled (checked every 4h)',
+    'doctor.updates.autoOff': '└ Auto-updates: disabled ({reason})',
+    'doctor.updates.lastAutoFailure': '└ Last automatic update: {detail}',
+    'doctor.diag.managedSettingsInvalid.issue': 'managed-settings.json: strictPluginOnlyCustomization has an invalid value (expected true or an array, got {type})',
+    'doctor.diag.managedSettingsInvalid.fix': 'The field is silently ignored (schema .catch rescues it). Set it to true, or an array of: {surfaces}.',
+    'doctor.diag.managedSettingsUnknown.issue': "managed-settings.json: strictPluginOnlyCustomization has {count} value(s) this client doesn't recognize: {values}",
+    'doctor.diag.managedSettingsUnknown.fix': 'These are silently ignored (forwards-compat). Known surfaces for this version: {surfaces}. Either remove them, or this client is older than the managed-settings intended.',
+    'doctor.diag.pathWindows.issue': 'Native installation exists but {path} is not in your PATH',
+    'doctor.diag.pathWindows.fix': 'Add it by opening: System Properties → Environment Variables → Edit User PATH → New → Add the path above. Then restart your terminal.',
+    'doctor.diag.pathUnix.issue': 'Native installation exists but ~/.local/bin is not in your PATH',
+    'doctor.diag.pathUnix.fix': 'Run: echo \'export PATH="$HOME/.local/bin:$PATH"\' >> {configFile} then open a new terminal or run: source {configFile}',
+    'doctor.diag.unknownShellConfig': 'your shell config file',
+    'doctor.diag.localMismatch.issue': "Running from local installation but config install method is '{method}'",
+    'doctor.diag.nativeMismatch.issue': "Running native installation but config install method is '{method}'",
+    'doctor.diag.considerNative.fix': 'Consider using native installation: sema install',
+    'doctor.diag.runSemaInstall.fix': 'Run sema install to update configuration',
+    'doctor.diag.localExists.issue': 'Local installation exists but not being used',
+    'doctor.diag.localNotAccessible.issue': 'Local installation not accessible',
+    'doctor.diag.localNotAccessibleAlias.fix': 'Alias exists but points to invalid target: {alias}. Update alias: alias claude="~/.sema/local/claude"',
+    'doctor.diag.localNotAccessibleNoAlias.fix': 'Create alias: alias claude="~/.sema/local/claude"',
+    'doctor.diag.linuxGlob.issue': 'Glob patterns in sandbox permission rules are not fully supported on Linux',
+    'doctor.diag.linuxGlob.fix': 'Found {count} pattern(s): {patterns}. On Linux, glob patterns in Edit/Read rules will be ignored.',
+    'doctor.diag.leftoverGlobal.issue': 'Leftover npm global installation at {path}',
+    'doctor.diag.orphanGlobal.issue': 'Orphaned npm global package at {path}',
+    'doctor.diag.leftoverLocal.issue': 'Leftover npm local installation at {path}',
+    'doctor.diag.runCmd.fix': 'Run: {cmd}',
+    'doctor.diag.insufficientPermissions.issue': 'Insufficient permissions for auto-updates',
+    'doctor.diag.insufficientPermissions.fix': 'Do one of: (1) Re-install node without sudo, or (2) Use `sema install` for native installation',
+    'model.subagent.tiersInert': "Subagent model {word} is a tier word, but this engine has no model tiers configured — the subagent will run on its parent's model.",
+    'model.subagent.chainUnbound': "Subagent model {word} is not bound on this engine (neither it nor any tier below it has a model) — the subagent will run on its parent's model.",
+    'model.subagent.bindingNotInCatalog': "Subagent model {word} is bound to a model that is not in this engine's model catalog — the subagent will run on its parent's model.",
+    'model.subagent.ambiguous': "Subagent model {word} matches more than one model name that differ only in case — spell it exactly; the subagent will run on its parent's model.",
+};
+export const EN_MESSAGES = Object.freeze(EN);

package/dist/i18n/messages.zh.d.ts

@@ -0,0 +1,3 @@
+import type { MessageKey } from './messages.en.js';
+export declare const ZH_MESSAGES: Readonly<Record<MessageKey, string>>;
+export declare const TERM_SLOTS: Readonly<Partial<Record<MessageKey, readonly string[]>>>;