@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/sessionRulesNamespaceFormsCapability.js

@@ -0,0 +1,29 @@
+import { engineCapValue } from './engineCapsCache.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
+const SESSION_RULES_NAMESPACE_FORMS_KEY = 'sessionRulesNamespaceForms';
+const CONFIRMED = Object.freeze({ kind: 'confirmed' });
+const ABSENT = Object.freeze({ kind: 'absent' });
+const DECLINED = Object.freeze({ kind: 'declined' });
+const UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const UNOBSERVED = Object.freeze({ kind: 'unobserved' });
+export function observedSessionRulesNamespaceForms(baseUrl) {
+    try {
+        const base = baseUrl === undefined ? engineWireTargetBaseUrl() : baseUrl;
+        const slot = engineCapValue(typeof base === 'string' ? base : undefined, SESSION_RULES_NAMESPACE_FORMS_KEY);
+        switch (slot.kind) {
+            case 'unobserved':
+                return UNOBSERVED;
+            case 'not_reported':
+                return ABSENT;
+            case 'unreadable':
+                return UNREADABLE;
+            case 'null':
+                return DECLINED;
+            case 'value':
+                return slot.value === true ? CONFIRMED : DECLINED;
+        }
+    }
+    catch {
+        return UNOBSERVED;
+    }
+}

package/dist/sessionSyncFileHistoryCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectSessionSyncFileHistoryCapability(caps) {
@@ -20,7 +20,7 @@ const reader = createEngineCapReader({
     name: 'sessionSyncFileHistory',
     project: projectSessionSyncFileHistoryCapability,
 });
-export function observedSessionSyncFileHistory(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedSessionSyncFileHistory(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function sessionSyncFileHistoryAvailable(reading) {

package/dist/settingsCredentialKeyPaths.js

@@ -1,4 +1,4 @@
-import { looksLikeKnownSecret, queryCarriesCredential } from './displayUntrusted.js';
+import { looksLikeKnownSecret, percentBoundaryReadingOf, queryCarriesCredential } from './displayUntrusted.js';
 const CREDENTIAL_WORDS = new Set([
     'key', 'keys', 'apikey', 'token', 'tokens', 'secret', 'secrets', 'password', 'passwd', 'pass', 'pwd', 'pin', 'otp',
     'auth', 'authorization', 'credential', 'credentials', 'cookie', 'cookies', 'session', 'private', 'cert', 'signature', 'salt',
@@ -6,6 +6,9 @@ const CREDENTIAL_WORDS = new Set([
 const CREDENTIAL_STEMS = ['PASSWORD', 'PASSWD', 'SECRET', 'TOKEN', 'APIKEY', 'CREDENTIAL', 'COOKIE', 'PRIVATE'];
 const CREDENTIAL_SUFFIXES = ['PASS', 'PWD', 'KEY', 'AUTH'];
 const SECRET_CONFIG_NAME = /(?:^|[-_.])(?:token|key|secret|password|authorization|credential|cookie)s?$/i;
+const FLATTENED_CREDENTIAL_TAILS = [
+    'apikey', 'token', 'tokens', 'secret', 'secrets', 'password', 'passwd', 'credential', 'credentials', 'cookie', 'cookies', 'authorization',
+];
 export function credentialNameWords(name) {
     if (typeof name !== 'string')
         return [];
@@ -24,17 +27,54 @@ export function isCredentialEnvName(name) {
     const upper = name.toUpperCase();
     return CREDENTIAL_STEMS.some((stem) => upper.includes(stem)) || CREDENTIAL_SUFFIXES.some((suffix) => upper.endsWith(suffix));
 }
+function legacyNameWords(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .split(/[_\-.\s]+/)
+        .filter((w) => w.length > 0)
+        .map((w) => w.toLowerCase());
+}
 export function isCredentialConfigKey(name) {
     if (typeof name !== 'string')
         return false;
     const words = credentialNameWords(name);
     const last = words[words.length - 1];
-    return SECRET_CONFIG_NAME.test(name) || (last !== undefined && CREDENTIAL_WORDS.has(last));
+    if (SECRET_CONFIG_NAME.test(name) || (last !== undefined && CREDENTIAL_WORDS.has(last)))
+        return true;
+    const legacy = legacyNameWords(name);
+    const legacyLast = legacy[legacy.length - 1];
+    if (legacyLast !== undefined && CREDENTIAL_WORDS.has(legacyLast))
+        return true;
+    const flattened = name.replace(/[_\-.\s]+/g, '').toLowerCase();
+    return FLATTENED_CREDENTIAL_TAILS.some((tail) => flattened.endsWith(tail));
 }
 const DECIMAL_INTEGER_RE = /^\s*\d+\s*$/;
-function stringCarriesCredential(value) {
-    if (looksLikeKnownSecret(value))
-        return true;
+function percentDecodeOnce(s) {
+    return s.indexOf('%') === -1 ? s : s.replace(/%([0-7][0-9A-Fa-f])/g, (_m, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+}
+const SCHEME_THEN_ENCODED_SPACE = /(?:^|[^A-Za-z0-9])(?:bearer|basic)(?:\+|%20)[^\s+%]{1,4096}/i;
+const FORM_READING_MAX_LAYERS = 3;
+function formEncodedCarriesCredential(value) {
+    if (value.indexOf('+') === -1 && value.indexOf('%') === -1)
+        return false;
+    let layer = value;
+    for (let depth = 0;; depth++) {
+        const boundary = percentBoundaryReadingOf(layer);
+        for (const reading of boundary === layer ? [layer] : [layer, boundary]) {
+            if (SCHEME_THEN_ENCODED_SPACE.test(reading))
+                return true;
+            if (reading.indexOf('+') !== -1 && looksLikeKnownSecret(reading.replace(/\+/g, ' ')))
+                return true;
+        }
+        const next = percentDecodeOnce(layer);
+        if (next === layer)
+            return false;
+        if (depth === FORM_READING_MAX_LAYERS)
+            return true;
+        layer = next;
+    }
+}
+function urlCarriesCredential(value) {
     const text = value.trim();
     if (!text.includes('://'))
         return false;
@@ -49,6 +89,21 @@ function stringCarriesCredential(value) {
         return true;
     return url.search.length > 1 && queryCarriesCredential(url.search.slice(1));
 }
+function stringCarriesCredential(value) {
+    if (looksLikeKnownSecret(value) || formEncodedCarriesCredential(value))
+        return true;
+    let layer = value;
+    for (let depth = 0;; depth++) {
+        if (urlCarriesCredential(layer))
+            return true;
+        if (depth === FORM_READING_MAX_LAYERS)
+            return false;
+        const next = percentDecodeOnce(layer);
+        if (next === layer)
+            return false;
+        layer = next;
+    }
+}
 const ENV_ASSIGNMENT_RE = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/s;
 const LONG_OPTION_RE = /^--?([A-Za-z][A-Za-z0-9_-]*)(?:=(.*))?$/s;
 const HEADER_FORM_RE = /^\s*([A-Za-z][A-Za-z0-9_-]*)\s*:\s*\S/;

package/dist/settingsHooksSalvage.d.ts

@@ -41,4 +41,5 @@ export declare function hooksSalvageMaskOf(dropped: readonly {
 }[]): HooksSalvageMask;
 export declare function salvageSettingsHooksEntries(doc: SettingsDocument | null | undefined): HooksSalvage;
 export declare const HOOK_SETTINGS_SOURCE_TEXT: Readonly<Record<HookSettingsSource, string>>;
+export declare function layerNotAppliedRefusesTurn(source: HookSettingsSource): boolean;
 export declare function settingsHooksSalvageNotice(salvage: HooksSalvage, source: HookSettingsSource, doc?: SettingsDocument | null): string | undefined;

package/dist/settingsHooksSalvage.js

@@ -1,4 +1,5 @@
 import { displayUntrusted } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { SETTINGS_CLASSIFY_HOOKS_CONFIG, } from './generated/settingsSchemaFns.js';
 const _tuplePins = [true, true, true, true, true, true];
 void _tuplePins;
@@ -116,6 +117,9 @@ export const HOOK_SETTINGS_SOURCE_TEXT = Object.freeze({
     localSettings: 'Local settings',
     flagSettings: 'Flag settings',
 });
+export function layerNotAppliedRefusesTurn(source) {
+    return source === 'policySettings';
+}
 const SALVAGE_LABEL_MAX = 80;
 const SALVAGE_PIECES_SHOWN = 3;
 const labelOf = (s) => (typeof s === 'number' ? String(s) : displayUntrusted(s, { max: SALVAGE_LABEL_MAX }));
@@ -194,11 +198,13 @@ export function settingsHooksSalvageNotice(salvage, source, doc) {
     try {
         if (salvage.outcome === 'loaded-partial') {
             const what = joinPhrases(salvage.dropped.map((d) => ({ key: d.path.join('\u0000'), text: dropPhrase(d, doc) })));
+            if (layerNotAppliedRefusesTurn(source))
+                return renderMessage(msg('config.hooks.salvage.managedPartial', { layer, what }));
             return `${layer}: ${what}. The rest of this file's hooks are applied.`;
         }
         if (salvage.outcome === 'rejected') {
             const why = joinPhrases(salvage.rejections.map((r) => ({ key: r.path.join('\u0000'), text: rejectionPhrase(r) })));
-            if (source === 'policySettings') {
+            if (layerNotAppliedRefusesTurn(source)) {
                 return `${layer}: hooks could not be loaded — ${why}. Requests are not sent while the managed hooks cannot be applied; ask your administrator to fix the managed settings.`;
             }
             return `${layer}: hooks were not loaded — ${why}; ${GUARD_RISK_TAIL}.`;

package/dist/settingsLayerAdmission.d.ts

@@ -0,0 +1,4 @@
+import type { HostSettingsLayer, WorkspaceTrustState } from './hostSettingsSource.js';
+export declare function layerAdmissionWord(layer: HostSettingsLayer, trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): string;
+export declare function layerAdmitted(layer: HostSettingsLayer, trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): boolean;
+export declare function admittedLayers<L extends HostSettingsLayer>(layers: readonly L[], trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): readonly L[];

package/dist/settingsLayerAdmission.js

@@ -0,0 +1,16 @@
+import { SETTINGS_LAYER_ADMISSION } from './generated/settingsSchemaFns.js';
+const TRUST_UNREADABLE_READING = 'declined';
+const ADMITTED = 'admitted';
+function layerAdmissionOf(layer, trust, category, member) {
+    const reading = trust === 'unreadable' ? TRUST_UNREADABLE_READING : trust;
+    return member === undefined ? SETTINGS_LAYER_ADMISSION(layer, reading, category) : SETTINGS_LAYER_ADMISSION(layer, reading, category, member);
+}
+export function layerAdmissionWord(layer, trust, category, member) {
+    return layerAdmissionOf(layer, trust, category, member);
+}
+export function layerAdmitted(layer, trust, category, member) {
+    return layerAdmissionOf(layer, trust, category, member) === ADMITTED;
+}
+export function admittedLayers(layers, trust, category, member) {
+    return layers.filter((layer) => layerAdmitted(layer, trust, category, member));
+}

package/dist/skillToolListsCapability.js

@@ -1,7 +1,7 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { msg, renderMessage } from './i18n/translate.js';
-import { ownDataField } from './ownKey.js';
+import { guardedRead, ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectSkillToolListsCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
@@ -21,13 +21,14 @@ const reader = createEngineCapReader({
     name: 'skillToolLists',
     project: projectSkillToolListsCapability,
 });
-export function observedSkillToolLists(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedSkillToolLists(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function skillToolListsAvailable(reading) {
-    if (reading.kind === 'present')
+    const kind = guardedRead(() => readOwnDataValue(reading, 'kind'));
+    if (kind === 'present')
         return 'yes';
-    if (reading.kind === 'absent' || reading.kind === 'not_reported')
+    if (kind === 'absent' || kind === 'not_reported')
         return 'no';
     return 'unknown';
 }

package/dist/skillsWireCaps.d.ts

@@ -21,4 +21,18 @@ export interface SkillSpecsOptions {
     skillToolLists?: SkillToolListsReading;
 }
 export declare function skillBaseDirOf(skillRoot: string | undefined, platform?: 'posix' | 'win32'): string | undefined;
+export type SkillToolListKey = 'allowedTools' | 'disallowedTools';
+export type SkillToolListsVerdict = {
+    readonly kind: 'ok';
+    readonly lists: {
+        allowedTools?: string[];
+        disallowedTools?: string[];
+    };
+} | {
+    readonly kind: 'bad';
+    readonly key: SkillToolListKey;
+    readonly index?: number;
+    readonly detail: string;
+};
+export declare function skillToolListsVerdict(source: object, reading: SkillToolListsReading | undefined): SkillToolListsVerdict;
 export declare function skillCommandsToSpecs(cmds: SkillCmdLike[], resolveBody: (cmd: SkillCmdLike) => string | null, opts?: SkillSpecsOptions): SkillSpecOnWire[];

package/dist/skillsWireCaps.js

@@ -1,4 +1,6 @@
 import { skillToolListsAvailable } from './skillToolListsCapability.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { appendOwnElement } from './ownKey.js';
 export function toCappedSpec(name, description, whenToUse, body) {
     const n = name.trim();
     const c = body.trim();
@@ -27,14 +29,14 @@ export function skillBaseDirOf(skillRoot, platform = 'posix') {
         return undefined;
     return skillRoot;
 }
-function readSkillToolList(skillName, key, cmd) {
-    const who = `skillCommandsToSpecs: skill ${JSON.stringify(skillName.slice(0, 80))} ${key}`;
+const SKILL_TOOL_LIST_READ_BUDGET = 100_000;
+function readSkillToolList(key, source) {
     const hint = 'The list is the skill’s own tool rule list and is sent exactly as given (entries are never dropped, repaired, reordered or truncated here), ' +
         'so a value that is not a list of strings is refused instead of being silently reduced.';
-    const unreadable = () => new TypeError(`${who} could not be read — reading it (the property, the array length or an entry) threw. ${hint}`);
+    const unreadable = () => new TypeError(`could not be read — reading it (the property, the array length or an entry) threw. ${hint}`);
     let v;
     try {
-        v = cmd[key];
+        v = source[key];
     }
     catch {
         throw unreadable();
@@ -49,7 +51,7 @@ function readSkillToolList(skillName, key, cmd) {
         throw unreadable();
     }
     if (!isArray) {
-        throw new TypeError(`${who} must be an array of strings or absent — got ${v === null ? 'null' : typeof v === 'object' ? 'a non-array object' : `typeof ${typeof v}`}. ${hint}`);
+        throw new TypeError(`must be an array of strings or absent — got ${v === null ? 'null' : typeof v === 'object' ? 'a non-array object' : `typeof ${typeof v}`}. ${hint}`);
     }
     const list = v;
     let lengthRead;
@@ -60,7 +62,10 @@ function readSkillToolList(skillName, key, cmd) {
         throw unreadable();
     }
     if (typeof lengthRead !== 'number' || !Number.isSafeInteger(lengthRead) || lengthRead < 0 || lengthRead > 4_294_967_295) {
-        throw new TypeError(`${who} must be an array of strings or absent — its length is not a valid array length. ${hint}`);
+        throw new TypeError(`must be an array of strings or absent — its length is not a valid array length. ${hint}`);
+    }
+    if (lengthRead > SKILL_TOOL_LIST_READ_BUDGET) {
+        throw new TypeError(renderMessage(msg('config.skills.toolListTooMany', { got: String(SKILL_TOOL_LIST_READ_BUDGET) })));
     }
     const n = lengthRead;
     const out = [];
@@ -73,18 +78,45 @@ function readSkillToolList(skillName, key, cmd) {
             throw unreadable();
         }
         if (typeof e !== 'string') {
-            throw new TypeError(`${who} must be an array of strings or absent — the entry at index ${i} is ${e === null ? 'null' : `typeof ${typeof e}`}. ${hint}`);
+            throw Object.assign(new TypeError(`must be an array of strings or absent — the entry at index ${i} is ${e === null ? 'null' : `typeof ${typeof e}`}. ${hint}`), { index: i });
         }
-        out.push(e);
+        appendOwnElement(out, e);
     }
     return out;
 }
+function refusalOf(e, key) {
+    const index = e.index;
+    return { kind: 'bad', key, ...(typeof index === 'number' ? { index } : {}), detail: e.message };
+}
+export function skillToolListsVerdict(source, reading) {
+    if (reading === undefined)
+        return { kind: 'ok', lists: {} };
+    let allowedTools;
+    let disallowedTools;
+    try {
+        allowedTools = readSkillToolList('allowedTools', source);
+    }
+    catch (e) {
+        return refusalOf(e, 'allowedTools');
+    }
+    try {
+        disallowedTools = readSkillToolList('disallowedTools', source);
+    }
+    catch (e) {
+        return refusalOf(e, 'disallowedTools');
+    }
+    const toolListsOn = skillToolListsAvailable(reading ?? { kind: 'unobserved' }) === 'yes';
+    const lists = {};
+    if (toolListsOn && allowedTools !== undefined)
+        lists.allowedTools = allowedTools;
+    if (toolListsOn && disallowedTools !== undefined)
+        lists.disallowedTools = disallowedTools;
+    return { kind: 'ok', lists };
+}
 export function skillCommandsToSpecs(cmds, resolveBody, opts) {
     const specs = [];
     const seen = new Set();
     const reading = opts?.skillToolLists;
-    const wired = reading !== undefined;
-    const toolListsOn = wired && skillToolListsAvailable(reading ?? { kind: 'unobserved' }) === 'yes';
     for (const cmd of cmds) {
         if (cmd.type !== 'prompt' || cmd.disableModelInvocation)
             continue;
@@ -96,15 +128,14 @@ export function skillCommandsToSpecs(cmds, resolveBody, opts) {
             continue;
         seen.add(spec.name);
         const baseDir = opts?.toolsRunHere === true ? skillBaseDirOf(cmd.skillRoot, opts.platform ?? 'posix') : undefined;
-        const allowedTools = wired ? readSkillToolList(spec.name, 'allowedTools', cmd) : undefined;
-        const disallowedTools = wired ? readSkillToolList(spec.name, 'disallowedTools', cmd) : undefined;
+        const verdict = skillToolListsVerdict(cmd, reading);
+        if (verdict.kind === 'bad') {
+            throw new TypeError(`skillCommandsToSpecs: skill ${JSON.stringify(spec.name.slice(0, 80))} ${verdict.key} ${verdict.detail}`);
+        }
         let wire = spec;
         if (baseDir !== undefined)
             wire = { ...wire, baseDir };
-        if (toolListsOn && allowedTools !== undefined)
-            wire = { ...wire, allowedTools };
-        if (toolListsOn && disallowedTools !== undefined)
-            wire = { ...wire, disallowedTools };
+        wire = { ...wire, ...verdict.lists };
         specs.push(wire);
     }
     return specs;

package/dist/slashCommandGate.d.ts

@@ -0,0 +1,24 @@
+import type { Capabilities } from '@sema-agent/sdk';
+import { SLASH_COMMAND_ROSTER_PIN, type SlashCommandBucket, type SlashCommandOverride, type SlashCommandPosture } from './slashCommandTable.js';
+export { SLASH_COMMAND_ROSTER_PIN };
+export type { SlashCommandBucket, SlashCommandOverride, SlashCommandPosture };
+export declare const SLASH_COMMAND_BUCKETS: Readonly<Record<SlashCommandBucket, readonly string[]>>;
+export type SlashCommandGateReason = 'cc-availability' | 'cc-isEnabled' | 'config-deny' | 'capability-absent' | 'capability-degraded' | 'hidden-from-help' | 'allowed';
+export type SlashCommandGateState = 'allowed' | 'degraded' | 'denied';
+export interface SlashCommandGateInput {
+    readonly name: string;
+    readonly source?: string;
+    readonly ccAvailable?: boolean;
+    readonly ccEnabled?: boolean;
+}
+export interface SlashCommandVerdict {
+    readonly state: SlashCommandGateState;
+    readonly visible: boolean;
+    readonly degraded: boolean;
+    readonly hidden: boolean;
+    readonly reason: SlashCommandGateReason;
+    readonly requiredCapability?: string;
+}
+export declare function slashCommandBucketOf(name: string): SlashCommandBucket | undefined;
+export declare function slashCommandOverrideOf(name: string): SlashCommandOverride | undefined;
+export declare function judgeSlashCommand(command: SlashCommandGateInput, capabilities: Capabilities | undefined): SlashCommandVerdict;

package/dist/slashCommandGate.js

@@ -0,0 +1,74 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+import { SLASH_COMMAND_BUCKET_FLEET_NA, SLASH_COMMAND_BUCKET_MAPPABLE_TO_SDK, SLASH_COMMAND_BUCKET_POSTURE_TABLE, SLASH_COMMAND_BUCKET_PURE_UI, SLASH_COMMAND_OVERRIDE_ROWS, SLASH_COMMAND_ROSTER_PIN, } from './slashCommandTable.js';
+export { SLASH_COMMAND_ROSTER_PIN };
+export const SLASH_COMMAND_BUCKETS = Object.freeze({
+    pureUI: SLASH_COMMAND_BUCKET_PURE_UI,
+    mappableToSdk: SLASH_COMMAND_BUCKET_MAPPABLE_TO_SDK,
+    fleetNA: SLASH_COMMAND_BUCKET_FLEET_NA,
+});
+const BUCKET_INDEX = new Map([
+    ...SLASH_COMMAND_BUCKET_PURE_UI.map((n) => [n, 'pureUI']),
+    ...SLASH_COMMAND_BUCKET_MAPPABLE_TO_SDK.map((n) => [n, 'mappableToSdk']),
+    ...SLASH_COMMAND_BUCKET_FLEET_NA.map((n) => [n, 'fleetNA']),
+]);
+const OVERRIDE_INDEX = new Map(SLASH_COMMAND_OVERRIDE_ROWS);
+export function slashCommandBucketOf(name) {
+    return typeof name === 'string' ? BUCKET_INDEX.get(name) : undefined;
+}
+export function slashCommandOverrideOf(name) {
+    return typeof name === 'string' ? OVERRIDE_INDEX.get(name) : undefined;
+}
+function capabilityPresent(capabilities, key) {
+    try {
+        const v = guardedRead(() => readOwnDataValue(capabilities, key));
+        if (typeof v === 'boolean')
+            return v;
+        if (typeof v === 'string')
+            return v.length > 0;
+        if (Array.isArray(v))
+            return v.length > 0;
+        return Boolean(v);
+    }
+    catch {
+        return false;
+    }
+}
+function slot(input, key) {
+    return guardedRead(() => readOwnDataValue(input, key));
+}
+function verdict(state, hidden, reason, requiredCapability) {
+    return Object.freeze({
+        state,
+        visible: state !== 'denied',
+        degraded: state === 'degraded',
+        hidden,
+        reason,
+        ...(requiredCapability !== undefined ? { requiredCapability } : {}),
+    });
+}
+export function judgeSlashCommand(command, capabilities) {
+    const rawName = slot(command, 'name');
+    const name = typeof rawName === 'string' ? rawName : '';
+    if (slot(command, 'ccAvailable') === false)
+        return verdict('denied', false, 'cc-availability');
+    if (slot(command, 'ccEnabled') === false)
+        return verdict('denied', false, 'cc-isEnabled');
+    const override = OVERRIDE_INDEX.get(name);
+    const bucket = BUCKET_INDEX.get(name);
+    const bucketPosture = (bucket !== undefined ? SLASH_COMMAND_BUCKET_POSTURE_TABLE[bucket] : undefined) ?? 'allow';
+    const explicit = override?.mode;
+    const mode = explicit === 'allow' || explicit === 'deny' ? explicit : bucketPosture;
+    if (mode === 'deny')
+        return verdict('denied', false, 'config-deny');
+    const source = slot(command, 'source');
+    const builtin = source === undefined || source === 'builtin';
+    const unbucketedFallthrough = builtin && bucket === undefined && explicit !== 'allow' && explicit !== 'deny';
+    const hidden = override?.hidden === true || unbucketedFallthrough;
+    const required = override?.requiredCapability;
+    if (required !== undefined && required !== '' && !capabilityPresent(capabilities, required)) {
+        if (override?.degradeWhenAbsent === true)
+            return verdict('degraded', hidden, 'capability-degraded', required);
+        return verdict('denied', false, 'capability-absent', required);
+    }
+    return verdict('allowed', hidden, hidden ? 'hidden-from-help' : 'allowed', required !== undefined && required !== '' ? required : undefined);
+}

package/dist/slashCommandTable.d.ts

@@ -0,0 +1,14 @@
+export declare const SLASH_COMMAND_ROSTER_PIN = "CC 2.1.187";
+export type SlashCommandBucket = 'pureUI' | 'mappableToSdk' | 'fleetNA';
+export type SlashCommandPosture = 'allow' | 'deny';
+export interface SlashCommandOverride {
+    readonly mode: 'allow' | 'deny' | 'auto';
+    readonly requiredCapability?: string;
+    readonly degradeWhenAbsent?: boolean;
+    readonly hidden?: boolean;
+}
+export declare const SLASH_COMMAND_BUCKET_POSTURE_TABLE: Readonly<Record<SlashCommandBucket, SlashCommandPosture>>;
+export declare const SLASH_COMMAND_BUCKET_PURE_UI: readonly string[];
+export declare const SLASH_COMMAND_BUCKET_MAPPABLE_TO_SDK: readonly string[];
+export declare const SLASH_COMMAND_BUCKET_FLEET_NA: readonly string[];
+export declare const SLASH_COMMAND_OVERRIDE_ROWS: readonly (readonly [string, SlashCommandOverride])[];

package/dist/slashCommandTable.js

@@ -0,0 +1,99 @@
+export const SLASH_COMMAND_ROSTER_PIN = 'CC 2.1.187';
+export const SLASH_COMMAND_BUCKET_POSTURE_TABLE = Object.freeze({
+    pureUI: 'allow',
+    mappableToSdk: 'allow',
+    fleetNA: 'deny',
+});
+export const SLASH_COMMAND_BUCKET_PURE_UI = Object.freeze([
+    'color', 'theme', 'tui', 'brief', 'scroll-speed', 'terminal-setup',
+    'help', 'exit', 'copy', 'export', 'diff', 'config',
+    'ide', 'add-dir', 'cd', 'powerup', 'feedback', 'btw',
+    'advisor', 'fast', 'effort', 'heapdump', 'version', 'stickers',
+    'keybindings', 'statusline', 'vim', 'install', 'passes', 'clear',
+    'recap',
+]);
+export const SLASH_COMMAND_BUCKET_MAPPABLE_TO_SDK = Object.freeze([
+    'init', 'init-verifiers', 'review', 'insights', 'team-onboarding', 'compact',
+    'context', 'resume', 'model', 'usage', 'cost', 'permissions',
+    'hooks', 'plan', 'memory', 'tasks', 'stop', 'workflows',
+    'skills', 'mcp', 'agents', 'plugin', 'reload-plugins', 'rename',
+    'branch', 'goal', 'commit-push-pr', 'import', 'explain-usage',
+]);
+export const SLASH_COMMAND_BUCKET_FLEET_NA = Object.freeze([
+    'files', 'think-back', 'thinkback-play', 'commit', 'login', 'logout',
+    'setup-bedrock', 'setup-vertex', 'upgrade', 'usage-credits', 'extra-usage', 'rate-limit-options',
+    'pro-trial-expired', 'desktop', 'session', 'teleport', 'remote-control', 'remote-env',
+    'web-setup', 'ultraplan', 'ultrareview', 'install-github-app', 'install-slack-app', 'design-login',
+    'autofix-pr', 'mobile', 'tag', 'privacy-settings',
+]);
+export const SLASH_COMMAND_OVERRIDE_ROWS = Object.freeze([
+    ['status', { mode: 'allow' }],
+    ['doctor', { mode: 'allow' }],
+    ['rewind', { mode: 'allow' }],
+    ['skill-doctor', { mode: 'allow' }],
+    ['memory-capture', { mode: 'allow' }],
+    ['init', { mode: 'auto' }],
+    ['init-verifiers', { mode: 'auto' }],
+    ['review', { mode: 'auto' }],
+    ['insights', { mode: 'auto' }],
+    ['team-onboarding', { mode: 'auto' }],
+    ['compact', { mode: 'auto', degradeWhenAbsent: true }],
+    ['context', { mode: 'auto', degradeWhenAbsent: true }],
+    ['resume', { mode: 'auto', requiredCapability: 'asyncRuns', degradeWhenAbsent: true }],
+    ['tasks', { mode: 'auto', requiredCapability: 'asyncRuns' }],
+    ['stop', { mode: 'auto', requiredCapability: 'asyncRuns' }],
+    ['workflows', { mode: 'auto', requiredCapability: 'asyncRuns' }],
+    ['usage', { mode: 'auto', requiredCapability: 'pricingConfigured', degradeWhenAbsent: true }],
+    ['cost', { mode: 'auto', requiredCapability: 'pricingConfigured', degradeWhenAbsent: true }],
+    ['stats', { mode: 'allow' }],
+    ['vim', { mode: 'auto', hidden: true }],
+    ['statusline', { mode: 'auto', hidden: true }],
+    ['permissions', { mode: 'auto', requiredCapability: 'approvals', degradeWhenAbsent: true }],
+    ['plan', { mode: 'auto', requiredCapability: 'approvals', degradeWhenAbsent: true }],
+    ['goal', { mode: 'auto', requiredCapability: 'approvals', degradeWhenAbsent: true }],
+    ['hooks', { mode: 'auto', degradeWhenAbsent: true }],
+    ['memory', { mode: 'auto', requiredCapability: 'memory' }],
+    ['model', { mode: 'auto' }],
+    ['skills', { mode: 'auto', degradeWhenAbsent: true }],
+    ['mcp', { mode: 'auto', degradeWhenAbsent: true }],
+    ['agents', { mode: 'auto', degradeWhenAbsent: true }],
+    ['plugin', { mode: 'auto', degradeWhenAbsent: true }],
+    ['reload-plugins', { mode: 'auto', degradeWhenAbsent: true }],
+    ['rename', { mode: 'auto', degradeWhenAbsent: true }],
+    ['branch', { mode: 'auto', degradeWhenAbsent: true }],
+    ['loops', { mode: 'deny' }],
+    ['update', { mode: 'deny' }],
+    ['collab', { mode: 'allow' }],
+    ['websearch', { mode: 'allow' }],
+    ['import', { mode: 'auto' }],
+    ['explain-usage', { mode: 'auto' }],
+    ['mobile', { mode: 'deny' }],
+    ['tag', { mode: 'deny' }],
+    ['files', { mode: 'deny' }],
+    ['privacy-settings', { mode: 'deny' }],
+    ['think-back', { mode: 'deny' }],
+    ['thinkback-play', { mode: 'deny' }],
+    ['commit', { mode: 'deny' }],
+    ['login', { mode: 'deny' }],
+    ['logout', { mode: 'deny' }],
+    ['setup-bedrock', { mode: 'deny' }],
+    ['setup-vertex', { mode: 'deny' }],
+    ['upgrade', { mode: 'deny' }],
+    ['usage-credits', { mode: 'deny' }],
+    ['extra-usage', { mode: 'deny' }],
+    ['rate-limit-options', { mode: 'allow' }],
+    ['pro-trial-expired', { mode: 'deny' }],
+    ['desktop', { mode: 'deny' }],
+    ['session', { mode: 'deny' }],
+    ['teleport', { mode: 'deny' }],
+    ['remote-control', { mode: 'deny' }],
+    ['remote-env', { mode: 'deny' }],
+    ['web-setup', { mode: 'deny' }],
+    ['ultraplan', { mode: 'deny' }],
+    ['ultrareview', { mode: 'deny' }],
+    ['install-github-app', { mode: 'deny' }],
+    ['install-slack-app', { mode: 'deny' }],
+    ['design-login', { mode: 'deny' }],
+    ['autofix-pr', { mode: 'deny' }],
+    ['daemon', { mode: 'allow', requiredCapability: 'asyncRuns', degradeWhenAbsent: true }],
+]);

package/dist/sqlEngineCapability.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { storeSeatOf, createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectSqlEngineCapability(caps) {
@@ -40,7 +40,7 @@ const reader = createEngineCapReader({
     name: 'sql',
     project: projectSqlEngineCapability,
 });
-export function observedSqlEngine(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedSqlEngine(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 const SQL_DETAIL_MAX = 40;

package/dist/steerPriorityCapability.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectSteerPriorityCapability(caps) {
@@ -26,7 +26,7 @@ const reader = createEngineCapReader({
     name: 'fleet.steerPriority',
     project: projectSteerPriorityCapability,
 });
-export function observedSteerPriority(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedSteerPriority(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function steerPriorityMode(reading) {

package/dist/storePostureCapability.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { storeSeatOf, createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { projectSqlEngineCapability } from './sqlEngineCapability.js';
 import { ownDataField } from './ownKey.js';
@@ -45,7 +45,7 @@ const reader = createEngineCapReader({
     name: 'store',
     project: projectStorePostureCapability,
 });
-export function observedStorePosture(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedStorePosture(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 function presentView(reading) {

package/dist/subagent/agentStateDetail.js

@@ -4,7 +4,7 @@ function own(v, key) {
         return undefined;
     try {
         const d = Object.getOwnPropertyDescriptor(v, key);
-        return d !== undefined && 'value' in d ? d.value : undefined;
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
     }
     catch {
         return undefined;