dsh-baize-rules 0.1.0

package/lib/command.js

@@ -0,0 +1,30 @@
+/**
+ * Thin dsh adapter for the `/rules` command: feeds the live `view` + current
+ * `defaultScope` into the dependency-free decision core (`core.ts`), then
+ * persists the resulting `nextView` (global → disk, session → memory) and any
+ * `/rules scope` default change.
+ *
+ * @module dsh-baize-rules/command
+ */
+import { runCommand } from "./core.js";
+import { view, writeGlobal, writeSession, readProject, writeProject } from "./store.js";
+/** The registered handler contract: adapt command input → core decision → persist. */
+export async function handle(ctx, invocation, runtime) {
+    const cwd = invocation.agent.session?.header?.cwd ?? '';
+    const v = await view(ctx, invocation.agent, { globalRulesPath: runtime.globalRulesPath });
+    const viewWithProject = cwd ? { ...v, project: await readProject(ctx, cwd) } : v;
+    const out = runCommand({
+        raw: invocation.rawInput,
+        view: viewWithProject,
+        defaultScope: runtime.getScope(),
+    });
+    if (out.nextView !== undefined) {
+        await writeGlobal(ctx, { globalRulesPath: runtime.globalRulesPath }, out.nextView.global);
+        await writeSession(ctx, invocation.agent.id, out.nextView.session);
+        if (cwd)
+            await writeProject(ctx, cwd, out.nextView.project ?? []);
+    }
+    if (out.defaultScope !== undefined)
+        runtime.setScope(out.defaultScope);
+    return out.ok ? { kind: 'success', text: out.text } : { kind: 'error', text: out.text };
+}

package/lib/core.js

@@ -0,0 +1,165 @@
+/**
+ * Dependency-free rules-command core: parsing, scope resolution, and CRUD
+ * application over a {@link RuleView}. No dsh runtime needed, so it is testable
+ * in the Loop 0 harness (`pnpm test`). The dsh-facing adapter (`command.ts`)
+ * feeds in the live `view` + `defaultScope` and persists `nextView`/`defaultScope`.
+ *
+ * @module dsh-baize-rules/core
+ */
+export const RULE_SCOPES = ['global', 'session', 'project'];
+const SCOPE_SET = new Set(RULE_SCOPES);
+/** Verbs where a trailing scope token is a *target* to modify, not an argument. */
+const SCOPE_MODIFIER_VERBS = new Set(['add', 'remove', 'enable', 'disable']);
+const USAGE = 'Usage: /rules [list|add <text>|remove <id>|edit <id> <text>|enable|disable <id>|scope <global|session|project>|clear <scope>|export]';
+/** Parse a `/rules` line into a verb + args, isolating an explicit scope keyword.
+ *  Scope is accepted as a **leading** token (`/rules global add …`) or a
+ *  **trailing** token (`/rules add … global`, only the LAST arg qualifies),
+ *  so a rule whose text merely contains "global" is never misread as a scope. */
+export function parseCommand(raw) {
+    const tokens = raw.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return { verb: undefined, args: [] };
+    let verb;
+    let scope;
+    let rest;
+    if (SCOPE_SET.has(tokens[0])) {
+        scope = tokens[0];
+        verb = tokens[1];
+        rest = tokens.slice(2);
+    }
+    else {
+        verb = tokens[0];
+        rest = tokens.slice(1);
+        // Strip a trailing scope only for verbs that take a *target* scope modifier,
+        // never for `scope`/`clear` where the scope is the argument itself.
+        if (verb !== undefined && SCOPE_MODIFIER_VERBS.has(verb) && rest.length > 0
+            && SCOPE_SET.has(rest[rest.length - 1])) {
+            scope = rest[rest.length - 1];
+            rest = rest.slice(0, -1);
+        }
+    }
+    return { verb, args: rest.filter(Boolean), scope };
+}
+/** Explicit scope wins, else the caller's default. */
+export function resolveScope(scope, fallback) {
+    return scope ?? fallback;
+}
+/** Mint a fully-specified rule (dependency-free; uses global `crypto.randomUUID`). */
+export function newRule(text, now = Date.now()) {
+    return {
+        id: crypto.randomUUID(),
+        text,
+        enabled: true,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+/** Return a new view with one rule appended to a scope. */
+function listOf(view, scope) {
+    return scope === 'global' ? view.global : scope === 'project' ? (view.project ?? []) : view.session;
+}
+function withList(view, scope, list) {
+    if (scope === 'global')
+        return { ...view, global: [...list] };
+    if (scope === 'project')
+        return { ...view, project: [...list] };
+    return { ...view, session: [...list] };
+}
+export function addRule(view, scope, rule) {
+    return withList(view, scope, [...listOf(view, scope), rule]);
+}
+/** Return a new view with a rule removed from one scope. */
+export function removeRule(view, scope, id) {
+    return withList(view, scope, listOf(view, scope).filter(rule => rule.id !== id));
+}
+/** Mutate a copy of a scope's rules for the given id; returns whether found. */
+export function mutate(view, scope, id, fn) {
+    return withList(view, scope, listOf(view, scope).map(rule => rule.id === id ? fn(rule) : rule));
+}
+/** Render a compact human-readable list of the active rules. */
+export function formatList(view) {
+    const line = (rule) => `[${rule.id.slice(0, 8)}] ${rule.enabled ? '' : '(disabled) '}${rule.text}`;
+    const parts = [];
+    if (view.project && view.project.length > 0) {
+        parts.push('Project:');
+        parts.push(...view.project.map(line));
+    }
+    if (view.global.length > 0) {
+        parts.push('Global:');
+        parts.push(...view.global.map(line));
+    }
+    if (view.session.length > 0) {
+        parts.push('Session:');
+        parts.push(...view.session.map(line));
+    }
+    return parts.length === 0 ? 'No active rules.' : parts.join('\n');
+}
+/** Apply one parsed `/rules` command to the given view + default scope. */
+export function runCommand(input) {
+    const { verb, args, scope } = parseCommand(input.raw);
+    if (verb === undefined || verb === 'list') {
+        return { ok: true, text: formatList(input.view) };
+    }
+    const chosen = resolveScope(scope, input.defaultScope);
+    switch (verb) {
+        case 'add': {
+            const text = args.join(' ');
+            if (text.length === 0) {
+                return { ok: false, text: USAGE };
+            }
+            return {
+                ok: true,
+                text: `Added rule to ${chosen}: ${text}`,
+                nextView: addRule(input.view, chosen, newRule(text)),
+            };
+        }
+        case 'remove': {
+            const id = args[0] ?? '';
+            if (id.length === 0)
+                return { ok: false, text: USAGE };
+            return {
+                ok: true,
+                text: `Removed rule ${id} from ${chosen}.`,
+                nextView: removeRule(input.view, chosen, id),
+            };
+        }
+        case 'enable':
+        case 'disable': {
+            const id = args[0] ?? '';
+            if (id.length === 0)
+                return { ok: false, text: USAGE };
+            const enable = verb === 'enable';
+            const next = mutate(input.view, chosen, id, rule => ({ ...rule, enabled: enable, updatedAt: Date.now() }));
+            return { ok: true, text: `${enable ? 'Enabled' : 'Disabled'} rule ${id}.`, nextView: next };
+        }
+        case 'edit': {
+            const id = args[0] ?? '';
+            const text = args.slice(1).join(' ');
+            if (id.length === 0 || text.length === 0)
+                return { ok: false, text: USAGE };
+            const list = listOf(input.view, chosen);
+            if (!list.some(rule => rule.id === id))
+                return { ok: false, text: `Rule ${id} not found.` };
+            const next = mutate(input.view, chosen, id, rule => ({ ...rule, text, updatedAt: Date.now() }));
+            return { ok: true, text: `Updated rule ${id}.`, nextView: next };
+        }
+        case 'scope': {
+            const nextScope = args[0];
+            if (nextScope === undefined || !SCOPE_SET.has(nextScope))
+                return { ok: false, text: USAGE };
+            return { ok: true, text: `Default scope is now ${nextScope}.`, defaultScope: nextScope };
+        }
+        case 'clear': {
+            const clearScope = args[0];
+            if (clearScope === undefined || !SCOPE_SET.has(clearScope))
+                return { ok: false, text: USAGE };
+            const next = clearScope === 'global' ? { ...input.view, global: [] } : { ...input.view, session: [] };
+            return { ok: true, text: `Cleared ${clearScope} rules.`, nextView: next };
+        }
+        case 'export': {
+            return { ok: true, text: JSON.stringify({ global: input.view.global, session: input.view.session }, null, 2) };
+        }
+        default:
+            return { ok: false, text: USAGE };
+    }
+}

package/lib/index.js

@@ -0,0 +1,81 @@
+/**
+ * User-set session/global must-do and must-not requirements injected at
+ * conversation start. Named for 白泽 (Baize), the beast that knows all and
+ * distinguishes right from wrong — hence the must/mustNot framing.
+ *
+ * @module dsh-baize-rules
+ */
+import z from '@deepseek-ai/schemastery';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { renderDigest, renderRules } from "./rules.js";
+import { view } from "./store.js";
+import { handle } from "./command.js";
+import { registerRulesApi } from "./api.js";
+/** Cordis plugin name used by loader diagnostics + the injected message source. */
+export const name = 'baize-rules';
+/** Services granted on `ctx` by cordis before `apply` runs. We use `ctx.agents`
+ *  (agent-plane scoping), `ctx.commands` (register /baize-rules), `ctx.fs`
+ *  (persist global + session rule files), and `ctx.webServer` (rules panel API);
+ *  each must be declared in `inject`. */
+export const inject = ['agents', 'commands', 'fs', 'webServer', 'sessions'];
+/** Schemastery validation for {@link Config}. */
+export const Config = z.object({
+    scope: z.union([z.const('global'), z.const('session')]),
+    maxBytes: z.number().required(),
+    globalRulesPath: z.string(),
+    injectAtEveryStep: z.boolean(),
+});
+/** Per-session digest of the last injected rules, used to suppress duplicate injection. */
+const lastInjected = /* @__PURE__ */ new WeakMap();
+/**
+ * Register a prepended pre-step listener that injects the rendered rules as a
+ * durable user message on conversation start, plus the `/rules` command.
+ * @param ctx - plugin context; listener and command dispose with it.
+ * @param config - scope, budget, and redundancy policy.
+ */
+export function apply(ctx, config) {
+    // `/rules scope` mutates this process-visible default, so the command and the
+    // pre-step view always read the current choice.
+    const mutableScope = { scope: config.scope };
+    ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
+        const decision = await next();
+        if (decision.kind === 'reject' || signal.aborted)
+            return decision;
+        const v = await view(ctx, agent, config);
+        const text = renderRules(v, config.maxBytes);
+        if (text === undefined)
+            return decision;
+        const digest = await renderDigest(v, config.maxBytes);
+        const previous = lastInjected.get(agent.session);
+        if (!config.injectAtEveryStep && previous !== undefined && previous === digest)
+            return decision;
+        lastInjected.set(agent.session, digest ?? '');
+        return {
+            kind: 'enter',
+            messages: [
+                ...decision.messages,
+                createUserMessage({
+                    content: [{ type: 'text', text }],
+                    source: { kind: 'plugin', plugin: name, form: 'snapshot', sections: [{ name, text }] },
+                }),
+            ],
+        };
+    }, { prepend: true });
+    ctx.effect(function* () {
+        const runtime = {
+            globalRulesPath: config.globalRulesPath,
+            getScope: () => mutableScope.scope,
+            setScope: (scope) => { mutableScope.scope = scope; },
+        };
+        yield ctx.commands.register({
+            name: 'baize-rules',
+            description: '查看/增删改 会话或全局的 必须/禁止 要求',
+            input: {
+                hint: 'list | add <text> | remove <id> | enable|disable <id> | scope <global|session|project> | clear <scope> | export',
+            },
+            handler: invocation => handle(ctx, invocation, runtime),
+        });
+    }, 'baize-rules lifecycle');
+    // Host HTTP API for the rules panel (client reads/writes here).
+    ctx.effect(() => registerRulesApi(ctx, { globalRulesPath: config.globalRulesPath }), 'baize-rules api');
+}

package/lib/invariant.js

@@ -0,0 +1,29 @@
+/**
+ * Package-owned invariant companion for `dsh-baize-rules`.
+ *
+ * Follows the @deepseek-ai/dsh-invariants contract used by other dsh context
+ * plugins (e.g. `@deepseek-ai/dsh-agent-instructions`): a Cordis companion that
+ * exports `name` / `inject=['invariants']` / `apply`, and registers itself via
+ * `ctx.invariants.register(PACKAGE_NAME, install)`.
+ *
+ * @module dsh-baize-rules/invariant
+ */
+const PACKAGE_NAME = 'dsh-baize-rules';
+/** Cordis companion plugin name. */
+export const name = 'baize-rules-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/**
+ * M1 hook: install a real check that any rules-tagged `user/message` in the
+ * session log carries the rules plugin's own source marker and reconstructs from
+ * the current rule set. For now it is an explainable no-op so it never blocks a
+ * session; the reference implementation's naive `registerInvariant` (a nonexistent
+ * export from a wrong package name) is replaced by this contract-correct shape.
+ */
+const install = () => { };
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));

package/lib/rules.js

@@ -0,0 +1,83 @@
+/**
+ * User-set rule data model, scope reconciliation, and the model-visible
+ * rendering shared by the pre-step injection and the /rules command.
+ *
+ * @module @deepseek-ai/dsh-rules/rules
+ */
+/** Concatenate global then session rules, honoring scope precedence. */
+export function activeRules(view) {
+    return [...view.global, ...view.session].filter(rule => rule.enabled);
+}
+/** Escape literal closing tags so user text cannot close the plugin frame. */
+export function escapeReminder(text) {
+    return text.replace(/<\/(?:system-reminder)\s*>/gi, '<\\/system-reminder>');
+}
+/** Enforce the configured byte budget by keeping the *prefix* (up to `budgetBytes`
+ *  UTF-8 bytes) and dropping the tail. Precedence is thus decided by callers:
+ *  {@link renderRules} lays the most specific section first, so a tight budget
+ *  sheds the broadest (global) rules before any specific (session/project) rule. */
+export function enforceBudget(lines, budgetBytes) {
+    if (budgetBytes <= 0)
+        return { lines: [], omitted: lines.length };
+    let bytes = 0;
+    const kept = [];
+    for (const line of lines) {
+        const next = bytes + Buffer.byteLength(line, 'utf8');
+        if (next > budgetBytes) {
+            return { lines: kept, omitted: lines.length - kept.length };
+        }
+        kept.push(line);
+        bytes = next;
+    }
+    return { lines: kept, omitted: 0 };
+}
+/** Section order by precedence, most specific first. Global stays last so a tight
+ *  budget drops the broadest rules before any specific (session/project) rule. */
+const SCOPE_ORDER = ['project', 'session', 'global'];
+function sectionHeader(scope) {
+    switch (scope) {
+        case 'project': return 'Project requirements (this directory only):';
+        case 'session': return 'Session requirements (this conversation only):';
+        default: return 'Global requirements:';
+    }
+}
+const RULE_BULLET = /^- /;
+/** Render the full model-visible <system-reminder> text, or undefined when empty.
+ *  Sections are laid out specific-first (project > session > global) so prefix
+ *  retention under {@link enforceBudget} keeps the specific rules and sheds the
+ *  broadest (global) rules first. Returns undefined when no rule bullet survives
+ *  the budget, so we never inject a boilerplate-only reminder. */
+export function renderRules(view, budgetBytes) {
+    const enabled = (rules) => (rules ?? []).filter(rule => rule.enabled);
+    const sections = SCOPE_ORDER
+        .map(scope => ({
+        scope,
+        rules: enabled(scope === 'project' ? view.project
+            : scope === 'session' ? view.session : view.global),
+    }))
+        .filter(section => section.rules.length > 0);
+    if (sections.length === 0)
+        return undefined;
+    const bullet = (rule) => `- ${escapeReminder(rule.text)}`;
+    const lines = [
+        'The following user requirements apply to every step of this conversation. Obey them.',
+        'More specific instructions take precedence over broader ones. They do not override system, developer, or direct user instructions.',
+    ];
+    for (const section of sections) {
+        lines.push('', sectionHeader(section.scope));
+        lines.push(...section.rules.map(bullet));
+    }
+    const { lines: kept } = enforceBudget(lines, budgetBytes);
+    if (!kept.some(line => RULE_BULLET.test(line)))
+        return undefined;
+    return `<system-reminder>\n${kept.join('\n')}\n</system-reminder>`;
+}
+/** SHA-1 digest of the rendered text, used to suppress redundant injection. */
+export async function renderDigest(view, budgetBytes) {
+    const text = renderRules(view, budgetBytes);
+    if (text === undefined)
+        return undefined;
+    const bytes = new TextEncoder().encode(text);
+    const hash = await crypto.subtle.digest('SHA-1', bytes);
+    return [...new Uint8Array(hash)].map(byte => byte.toString(16).padStart(2, '0')).join('');
+}

package/lib/store.js

@@ -0,0 +1,130 @@
+/**
+ * Durable rule store: `global` and `session` rules both persist to JSON files
+ * under DSH_HOME — `global` to `$DSH_HOME/rules/global.json`, and each session's
+ * rules to `$DSH_HOME/rules/sessions/<sessionId>.json`. Files are read lazily at
+ * every view/pre-step and written on every mutating `/rules` command, so both
+ * scopes survive process restarts. `ctx.fs.writeText` creates parent dirs.
+ *
+ * Note: an event-sourced `rules/set` session event (方案 A) would be the cleanest
+ * "model-visible ⟺ logged" guarantee, but the public `Session.append` cannot mark
+ * an out-of-repo event type `ignorable`, so a harness reading such a log would
+ * refuse to reconstruct it. The per-session file is the pragmatic durable path.
+ *
+ * Pure CRUD helpers (addRule/removeRule/mutate/newRule) live in `core.ts`.
+ *
+ * @module dsh-baize-rules/store
+ */
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+/** Resolve the global rules path (config override, else `$DSH_HOME/rules/global.json`). */
+function globalRulesPath(ctx, config) {
+    return config.globalRulesPath ?? dshHomePath('rules', 'global.json');
+}
+/** Resolve one session's rules file: `$DSH_HOME/rules/sessions/<sessionId>.json`. */
+function sessionRulesPath(sessionId) {
+    return dshHomePath('rules', 'sessions', `${String(sessionId)}.json`);
+}
+/** Slug a project (cwd) into a safe filename for `$DSH_HOME/rules/projects/<slug>.json`. */
+function projectSlug(projectId) {
+    return String(projectId).replace(/[\\/:*?"<>|]/g, '_').replace(/^_+|_+$/g, '') || '_';
+}
+/** Resolve one project's rules file (project = session cwd). */
+function projectRulesPath(projectId) {
+    return dshHomePath('rules', 'projects', `${projectSlug(projectId)}.json`);
+}
+/** Read a project's rule set from its durable file (empty when missing). */
+export async function readProject(ctx, projectId) {
+    if (ctx.fs === undefined || projectId === undefined || String(projectId).length === 0)
+        return [];
+    const path = projectRulesPath(projectId);
+    const target = await ctx.fs.resolve(path);
+    const info = await ctx.fs.stat(target);
+    if (info === undefined)
+        return [];
+    const raw = await ctx.fs.readText(target);
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+        throw new Error(`rules: project rules file is not a JSON array: ${path}`);
+    return sanitizeRules(parsed);
+}
+/** Replace a project's rule set in its durable file. */
+export async function writeProject(ctx, projectId, rules) {
+    if (ctx.fs === undefined || projectId === undefined || String(projectId).length === 0)
+        return;
+    const path = projectRulesPath(projectId);
+    const target = await ctx.fs.resolve(path);
+    await ctx.fs.writeText(target, `${JSON.stringify(rules, null, 2)}\n`);
+}
+/** Validate a parsed array into well-formed rules; drop the malformed entries loudly.
+ *  Rules are plain text — there is no `kind` field anymore, but legacy stored
+ *  entries that carried `kind` are accepted (the field is ignored on rewrite). */
+function sanitizeRules(parsed) {
+    return parsed.flatMap((item) => {
+        if (typeof item !== 'object' || item === null)
+            throw new Error('rules: entry is not an object');
+        const rule = item;
+        const { text, id } = rule;
+        if (typeof text !== 'string' || typeof id !== 'string') {
+            throw new Error('rules: entry must carry string id and text');
+        }
+        return [{
+                id,
+                text,
+                enabled: rule.enabled !== false,
+                createdAt: typeof rule.createdAt === 'number' ? rule.createdAt : 0,
+                updatedAt: typeof rule.updatedAt === 'number' ? rule.updatedAt : 0,
+            }];
+    });
+}
+/** Read the global rule set, tolerating a missing file and failing loud on a malformed store. */
+export async function readGlobal(ctx, config) {
+    if (ctx.fs === undefined)
+        return [];
+    const path = globalRulesPath(ctx, config);
+    const target = await ctx.fs.resolve(path);
+    const info = await ctx.fs.stat(target);
+    if (info === undefined)
+        return [];
+    const raw = await ctx.fs.readText(target);
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+        throw new Error(`rules: global rules file is not a JSON array: ${path}`);
+    return sanitizeRules(parsed);
+}
+/** Write the global rule set. */
+export async function writeGlobal(ctx, config, rules) {
+    if (ctx.fs === undefined)
+        return;
+    const path = globalRulesPath(ctx, config);
+    const target = await ctx.fs.resolve(path);
+    await ctx.fs.writeText(target, `${JSON.stringify(rules, null, 2)}\n`);
+}
+/** Read the per-session rule set from its durable file (empty when missing). */
+export async function readSession(ctx, sessionId) {
+    if (ctx.fs === undefined)
+        return [];
+    const path = sessionRulesPath(sessionId);
+    const target = await ctx.fs.resolve(path);
+    const info = await ctx.fs.stat(target);
+    if (info === undefined)
+        return [];
+    const raw = await ctx.fs.readText(target);
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+        throw new Error(`rules: session rules file is not a JSON array: ${path}`);
+    return sanitizeRules(parsed);
+}
+/** Replace the per-session rule set in its durable file. */
+export async function writeSession(ctx, sessionId, rules) {
+    if (ctx.fs === undefined)
+        return;
+    const path = sessionRulesPath(sessionId);
+    const target = await ctx.fs.resolve(path);
+    await ctx.fs.writeText(target, `${JSON.stringify(rules, null, 2)}\n`);
+}
+/** Assemble the merged view used for injection and /rules list. */
+export async function view(ctx, agent, config) {
+    return {
+        global: await readGlobal(ctx, config),
+        session: await readSession(ctx, agent.id),
+    };
+}

package/lib/types/api.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Host HTTP API for the rules panel. The client (`lib/client.js`) fetches rules
+ * via GET and applies mutations via POST, reusing the same store + core as the
+ * `/baize-rules` command (so the panel and command are the same source of truth).
+ *
+ * Routes (json):
+ *   GET  /baize-rules.api?sessionId=...  -> { global, session }
+ *   POST /baize-rules.api { sessionId, raw, scope } -> { ok, text, view }
+ *
+ * @module dsh-baize-rules/api
+ */
+import type { Context } from '@deepseek-ai/cordis';
+type RulesApiOptions = {
+    globalRulesPath?: string;
+};
+/** Register the rules panel API on the host web server. */
+export declare function registerRulesApi(ctx: Context, options?: RulesApiOptions): () => void;
+export {};

package/lib/types/command.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Thin dsh adapter for the `/rules` command: feeds the live `view` + current
+ * `defaultScope` into the dependency-free decision core (`core.ts`), then
+ * persists the resulting `nextView` (global → disk, session → memory) and any
+ * `/rules scope` default change.
+ *
+ * @module dsh-baize-rules/command
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { CommandInvocation, CommandResult } from '@deepseek-ai/dsh-commands';
+import type { RuleScope } from './rules.ts';
+/** Runtime state the command handler needs from the plugin's `apply`. */
+export interface RulesRuntime {
+    readonly globalRulesPath?: string;
+    readonly getScope: () => RuleScope;
+    readonly setScope: (scope: RuleScope) => void;
+}
+/** The registered handler contract: adapt command input → core decision → persist. */
+export declare function handle(ctx: Context, invocation: CommandInvocation, runtime: RulesRuntime): Promise<CommandResult>;

package/lib/types/core.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Dependency-free rules-command core: parsing, scope resolution, and CRUD
+ * application over a {@link RuleView}. No dsh runtime needed, so it is testable
+ * in the Loop 0 harness (`pnpm test`). The dsh-facing adapter (`command.ts`)
+ * feeds in the live `view` + `defaultScope` and persists `nextView`/`defaultScope`.
+ *
+ * @module dsh-baize-rules/core
+ */
+import type { Rule, RuleScope, RuleView } from './rules.ts';
+export declare const RULE_SCOPES: readonly RuleScope[];
+export type CommandVerb = 'list' | 'add' | 'remove' | 'enable' | 'disable' | 'edit' | 'scope' | 'clear' | 'export';
+export interface ParsedCommand {
+    readonly verb: CommandVerb | 'help' | undefined;
+    readonly args: readonly string[];
+    /** Explicit scope keyword (leading or trailing), if present. */
+    readonly scope?: RuleScope;
+}
+export interface CommandInput {
+    readonly raw: string;
+    readonly view: RuleView;
+    readonly defaultScope: RuleScope;
+}
+export interface CommandOutput {
+    readonly ok: boolean;
+    readonly text: string;
+    /** Present when the store should be persisted to this new view. */
+    readonly nextView?: RuleView;
+    /** Present when `/rules scope` chose a new default scope. */
+    readonly defaultScope?: RuleScope;
+}
+/** Parse a `/rules` line into a verb + args, isolating an explicit scope keyword.
+ *  Scope is accepted as a **leading** token (`/rules global add …`) or a
+ *  **trailing** token (`/rules add … global`, only the LAST arg qualifies),
+ *  so a rule whose text merely contains "global" is never misread as a scope. */
+export declare function parseCommand(raw: string): ParsedCommand;
+/** Explicit scope wins, else the caller's default. */
+export declare function resolveScope(scope: RuleScope | undefined, fallback: RuleScope): RuleScope;
+/** Mint a fully-specified rule (dependency-free; uses global `crypto.randomUUID`). */
+export declare function newRule(text: string, now?: number): Rule;
+export declare function addRule(view: RuleView, scope: RuleScope, rule: Rule): RuleView;
+/** Return a new view with a rule removed from one scope. */
+export declare function removeRule(view: RuleView, scope: RuleScope, id: string): RuleView;
+/** Mutate a copy of a scope's rules for the given id; returns whether found. */
+export declare function mutate(view: RuleView, scope: RuleScope, id: string, fn: (rule: Rule) => Rule): RuleView;
+/** Render a compact human-readable list of the active rules. */
+export declare function formatList(view: RuleView): string;
+/** Apply one parsed `/rules` command to the given view + default scope. */
+export declare function runCommand(input: CommandInput): CommandOutput;

package/lib/types/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * User-set session/global must-do and must-not requirements injected at
+ * conversation start. Named for 白泽 (Baize), the beast that knows all and
+ * distinguishes right from wrong — hence the must/mustNot framing.
+ *
+ * @module dsh-baize-rules
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+/** Cordis plugin name used by loader diagnostics + the injected message source. */
+export declare const name = "baize-rules";
+/** Services granted on `ctx` by cordis before `apply` runs. We use `ctx.agents`
+ *  (agent-plane scoping), `ctx.commands` (register /baize-rules), `ctx.fs`
+ *  (persist global + session rule files), and `ctx.webServer` (rules panel API);
+ *  each must be declared in `inject`. */
+export declare const inject: string[];
+/** Policy for the rules plugin. Invalid values fail plugin load. */
+export interface Config {
+    /** Default scope that `/rules add|remove|...` edits when the line omits a scope keyword. */
+    scope: 'global' | 'session';
+    /** Model-visible byte budget; a tight budget sheds the broadest rules first. */
+    maxBytes: number;
+    /** Override the global rules file path (default `$DSH_HOME/rules/global.json`). */
+    globalRulesPath?: string;
+    /** When true, re-render an updated rules message on every step, not just on change. */
+    injectAtEveryStep?: boolean;
+}
+/** Schemastery validation for {@link Config}. */
+export declare const Config: z<Config>;
+/**
+ * Register a prepended pre-step listener that injects the rendered rules as a
+ * durable user message on conversation start, plus the `/rules` command.
+ * @param ctx - plugin context; listener and command dispose with it.
+ * @param config - scope, budget, and redundancy policy.
+ */
+export declare function apply(ctx: Context, config: Config): void;

package/lib/types/invariant.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Package-owned invariant companion for `dsh-baize-rules`.
+ *
+ * Follows the @deepseek-ai/dsh-invariants contract used by other dsh context
+ * plugins (e.g. `@deepseek-ai/dsh-agent-instructions`): a Cordis companion that
+ * exports `name` / `inject=['invariants']` / `apply`, and registers itself via
+ * `ctx.invariants.register(PACKAGE_NAME, install)`.
+ *
+ * @module dsh-baize-rules/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "baize-rules-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;