@cratis/pi 2.22.0 → 2.23.1

package/package/corpus/agents/backend-developer.md

@@ -7,11 +7,12 @@ description: >
   and reactors — all in strict compliance with the vertical slice architecture.
 model: claude-sonnet-4-5
 tools:
-  - githubRepo
-  - codeSearch
-  - usages
-  - rename
-  - terminalLastCommand
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - Edit
+  - Write
 ---
 
 # Backend Developer

package/package/corpus/agents/code-reviewer.md

@@ -6,11 +6,11 @@ description: >
   TypeScript conventions, and vertical slice correctness before merge.
 model: claude-sonnet-4-5
 tools:
-  - githubRepo
-  - codeSearch
-  - usages
-  - rename
-  - terminalLastCommand
+  - Read
+  - Grep
+  - Glob
+  - Bash
+readonly: true
 ---
 
 # Code Reviewer
@@ -110,7 +110,7 @@ When checking unused code, references, or naming, use semantic navigation if the
 
 ## TypeScript Styling checklist
 
-- [ ] No hard-coded hex/rgb values — PrimeReact CSS variables used
+- [ ] No hard-coded hex/rgb values — `--cratis-*` tokens used
 - [ ] CSS co-located with component (`.css` file in same folder)
 - [ ] No `!important` unless absolutely required and justified with a comment
 
@@ -128,7 +128,7 @@ When checking unused code, references, or naming, use semantic navigation if the
 - [ ] README.md exists for complex component folders
 - [ ] `CommandDialog` from `@cratis/components/CommandDialog` used for command-based dialogs
 - [ ] `Dialog` from `@cratis/components/Dialogs` used for data-only dialogs
-- [ ] Never imports `Dialog` directly from `primereact/dialog`
+- [ ] Never uses a vendor or hand-rolled modal — `CommandDialog` / `Dialog` from Cratis Components
 - [ ] No monolithic components — decomposed into smaller, focused sub-components
 
 ---

package/package/corpus/agents/coordinator.md

@@ -10,10 +10,11 @@ description: >
   and review).
 model: claude-sonnet-4-5
 tools:
-  - githubRepo
-  - codeSearch
-  - usages
-  - terminalLastCommand
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - Agent
 ---
 
 # Coordinator

package/package/corpus/agents/frontend-developer.md

@@ -6,11 +6,12 @@ description: >
   proxies, following the project's component and styling conventions.
 model: claude-sonnet-4-5
 tools:
-  - githubRepo
-  - codeSearch
-  - usages
-  - rename
-  - terminalLastCommand
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - Edit
+  - Write
 ---
 
 # Frontend Developer
@@ -64,7 +65,7 @@ Confirm that the TypeScript proxies exist in the slice folder before writing any
 - Place `.tsx` files in the **same folder** as the corresponding `.cs` file.
 - Do NOT prefix the file name with the feature or slice name (folder provides context).
 - Each component has its own `.css` file for static styles.
-- Use PrimeReact CSS variables for all colors, backgrounds, and borders — never hard-code hex values. The default stack is Cratis Components on PrimeReact theming — not Tailwind.
+- Use the `--cratis-*` design tokens for all colors, backgrounds, and borders — never hard-code hex values. The default stack is Cratis Components 4 (Components-owned markup and tokens; no PrimeReact) — not Tailwind.
 - Use `const` over `let`.
 - Use full descriptive names (never abbreviations like `e`, `idx`, `prev`).
 - **Move non-trivial state out of the render function** into a `withViewModel` view model (or a tested state module) — see `react.md`. Extract as soon as a component has 3+ `useState`, a state-syncing `useEffect`, or derived values. A view model is a plain class with no React hooks, constructible in a spec.
@@ -90,28 +91,22 @@ const handleSubmit = async () => {
 ## Query usage pattern (with paging)
 
 ```tsx
-const pageSize = 10;
-
-export const Listing = () => {
-    const [allProjectsResult, , setPage] = AllProjects.useWithPaging(pageSize);
-
-    return (
-        <DataTable
-            lazy paginator
-            value={allProjectsResult.data}
-            rows={pageSize}
-            totalRecords={allProjectsResult.paging.totalItems}
-            alwaysShowPaginator={false}
-            first={allProjectsResult.paging.page * pageSize}
-            onPage={event => setPage(event.page ?? 0)}
-            scrollable scrollHeight="flex"
-            emptyMessage="No items found.">
-            <Column field="name" header="Name" />
-        </DataTable>
-    );
-};
+import { DataTableForQuery, Column } from '@cratis/components/DataTables';
+import { AllProjects } from './AllProjects';
+
+// The table subscribes to the query itself and pages server-side (20 rows a page);
+// do not fetch rows and pass an items array.
+export const Listing = () => (
+    <DataTableForQuery query={AllProjects} emptyMessage="No items found.">
+        <Column field="name" header="Name" />
+    </DataTableForQuery>
+);
 ```
 
+For caller-controlled paging outside a table, use the proxy hook directly —
+`const [result, , , setPage] = AllProjects.useWithPaging(pageSize)`; `result.data` and
+`result.paging` (`page`, `size`, `totalItems`, `totalPages`) drive your own layout.
+
 ---
 
 ## Dialog patterns
@@ -133,7 +128,7 @@ export const AddProject = ({ closeDialog }: DialogProps) => {
             title="Add Project"
             okLabel="Add"
             cancelLabel="Cancel"
-            onConfirm={() => closeDialog(DialogResult.Ok)}
+            onSuccess={() => closeDialog(DialogResult.Ok)}
             onCancel={() => closeDialog(DialogResult.Cancelled)}
         >
             <InputTextField<RegisterProject>
@@ -157,7 +152,7 @@ Use this for dialogs that collect data and return it without executing a command
 import { useState } from 'react';
 import { DialogProps, DialogResult } from '@cratis/arc.react/dialogs';
 import { Dialog } from '@cratis/components/Dialogs';
-import { InputText } from 'primereact/inputtext';
+import { TextInput } from '@cratis/components/Common';
 
 export const AddProject = ({ closeDialog }: DialogProps<{ name: string }>) => {
     const [name, setName] = useState('');
@@ -173,18 +168,18 @@ export const AddProject = ({ closeDialog }: DialogProps<{ name: string }>) => {
             onConfirm={() => closeDialog(DialogResult.Ok, { name })}
             onCancel={() => closeDialog(DialogResult.Cancelled)}
         >
-            <InputText
+            <TextInput
                 value={name}
-                onChange={event => setName(event.target.value)}
+                onChange={value => setName(value)}
                 placeholder="Enter a name"
-                autoFocus
+                aria-label="Project name"
             />
         </Dialog>
     );
 };
 ```
 
-> **Never** import `Dialog` from `primereact/dialog` directly.
+> **Never** use a vendor or hand-rolled modal — dialogs are Components-owned.
 
 ---
 
@@ -195,20 +190,19 @@ import { Page } from '@cratis/components/Common';
 import { AddProject } from './Registration/AddProject';
 import { Listing } from './Listing/Listing';
 import { DialogResult, useDialog } from '@cratis/arc.react/dialogs';
-import { Button } from 'primereact/button';
-import * as mdIcons from 'react-icons/md';
+import { Button } from '@cratis/components/Common';
+import { MdAdd } from 'react-icons/md';
 
 export const Projects = () => {
     const [AddProjectDialog, showAddProjectDialog] = useDialog(AddProject);
 
     // For a query-backed list page, prefer `DataPage` with `<DataPage.MenuItems>`
-    // (it owns the action bar). PrimeReact 11 removed the standalone `Menubar`;
-    // for a custom toolbar, compose `Button`s (content is children in v11).
+    // (it owns the action bar). For a custom action row, compose Components `Button`s
+    // (`variant`: solid | outline | ghost | link; `tone`: neutral | accent | positive | caution | critical).
     return (
         <Page title="Projects">
-            <Button variant="text" onClick={() => showAddProjectDialog()}>
-                <mdIcons.MdAdd />
-                <span>Add Project</span>
+            <Button variant="ghost" icon={<MdAdd aria-hidden="true" />} onClick={() => showAddProjectDialog()}>
+                Add Project
             </Button>
             <Listing />
             <AddProjectDialog />
@@ -238,7 +232,7 @@ Before handing back:
 - [ ] `npx tsc -b` passes with zero errors
 - [ ] Components are in the correct slice folder
 - [ ] If the app has a localization convention, user-visible text is routed through it (product policy — not a Cratis rule)
-- [ ] No hard-coded hex/rgb color values — PrimeReact CSS variables used throughout
+- [ ] No hard-coded hex/rgb color values — `--cratis-*` tokens used throughout
 - [ ] All variable/parameter names are fully descriptive (no abbreviations)
 - [ ] No `any` types — `unknown` with type guards where needed
 - [ ] Composition page updated to include the new component

package/package/corpus/agents/orchestrator.md

@@ -10,10 +10,11 @@ description: >
   large refactors, or any goal that spans more than one concern.
 model: claude-sonnet-4-5
 tools:
-  - githubRepo
-  - codeSearch
-  - usages
-  - terminalLastCommand
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - Agent
 ---
 
 # Orchestrator

package/package/corpus/agents/performance-reviewer.md

@@ -6,10 +6,11 @@ description: >
   React render overhead, and Chronicle anti-patterns before merge.
 model: claude-sonnet-4-5
 tools:
-  - githubRepo
-  - codeSearch
-  - usages
-  - terminalLastCommand
+  - Read
+  - Grep
+  - Glob
+  - Bash
+readonly: true
 ---
 
 # Performance Reviewer

package/package/corpus/agents/planner.md

@@ -7,10 +7,11 @@ description: >
   the work is considered done.
 model: claude-sonnet-4-5
 tools:
-  - githubRepo
-  - codeSearch
-  - usages
-  - terminalLastCommand
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - Agent
 ---
 
 # Vertical Slice Planner

package/package/corpus/agents/repository-investigation-reviewer.md

@@ -7,8 +7,9 @@ description: >
 model: claude-opus-5
 tools:
   - Read
-  - Glob
   - Grep
+  - Glob
+readonly: true
 ---
 
 # Repository Investigation Reviewer

package/package/corpus/agents/repository-investigator.md

@@ -7,9 +7,10 @@ description: >
 model: claude-opus-5
 tools:
   - Read
-  - Glob
   - Grep
+  - Glob
   - Bash
+readonly: true
 ---
 
 # Repository Investigator

package/package/corpus/agents/security-reviewer.md

@@ -7,10 +7,11 @@ description: >
   attack surface.
 model: claude-sonnet-4-5
 tools:
-  - githubRepo
-  - codeSearch
-  - usages
-  - terminalLastCommand
+  - Read
+  - Grep
+  - Glob
+  - Bash
+readonly: true
 ---
 
 # Security Reviewer

package/package/corpus/agents/slice-implementer.md

@@ -5,7 +5,13 @@ description: >
   in when_*/ folders, and the React surface (page and/or command dialog). Use for new slices and for
   non-trivial slice changes spanning backend and frontend.
 model: claude-opus-4-8
-tools: [githubRepo, codeSearch, usages, rename, terminalLastCommand]
+tools:
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - Edit
+  - Write
 ---
 
 # Slice Implementer
@@ -52,7 +58,7 @@ Proxies now exist. Build React components from the generated proxies (`react.md`
 - Events: no arguments on `[EventType]`, non-nullable, past tense, `<summary>`, never carry the event-source id.
 - `[OnceOnly]` on non-idempotent reactor side effects; reactors return side-effect events or use `ICommandPipeline` (never `IEventLog`).
 - Specs `#if DEBUG`, command aliased, per-test unique values.
-- Frontend via `withViewModel` + Arc proxy hooks + Cratis Components; never edit generated proxies; never import `Dialog` from `primereact/dialog`.
+- Frontend via `withViewModel` + Arc proxy hooks + Cratis Components; never edit generated proxies; never use a vendor or hand-rolled modal (dialogs come from `@cratis/components/CommandDialog` and `/Dialogs`).
 
 ## Output
 

package/package/corpus/agents/spec-writer.md

@@ -6,10 +6,12 @@ description: >
   comprehensive behavior coverage following the project's BDD conventions.
 model: claude-sonnet-4-5
 tools:
-  - githubRepo
-  - codeSearch
-  - usages
-  - terminalLastCommand
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - Edit
+  - Write
 ---
 
 # Spec Writer

package/package/corpus/harnesses/pi/extensions/cratis-rules/index.ts

@@ -1,27 +1,250 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 
 const corpusRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..');
 
-/** Loads every rule from the managed corpus, including general guidance when AGENTS.md is project-owned. */
-export function managedRules(cwd: string): string {
+type AiConfiguration = { profiles?: string[] };
+
+export interface ManagedRule {
+    /** Path relative to the rules root, e.g. `code-quality-csharp.md` or `project/running-the-local-stack.md`. */
+    name: string;
+    /** Full file content, frontmatter included, exactly as the other harnesses receive it. */
+    content: string;
+    /** `application`, `framework`, or undefined when the rule is not profile-specific. */
+    profile?: string;
+    /** Globs from `applyTo` and `paths`. Empty means the rule applies to every file. */
+    globs: string[];
+}
+
+const universalGlobs = new Set(['**', '**/*', '*']);
+
+function unquote(value: string): string {
+    return value.trim().replace(/^["']|["']$/g, '');
+}
+
+/**
+ * Reads the YAML-ish frontmatter the corpus uses: scalar `key: value` lines and `key:` followed by
+ * `  - item` lines. Anything richer is not used by the rules and is deliberately not supported.
+ */
+function frontmatter(content: string): Map<string, string[]> {
+    const fields = new Map<string, string[]>();
+    if (!content.startsWith('---\n')) return fields;
+    const end = content.indexOf('\n---\n', 4);
+    if (end < 0) return fields;
+    let current: string | undefined;
+    for (const line of content.slice(4, end).split('\n')) {
+        const item = /^\s+-\s+(.*)$/.exec(line);
+        if (item && current) {
+            fields.get(current)!.push(unquote(item[1]));
+            continue;
+        }
+        const scalar = /^([A-Za-z][\w-]*):\s*(.*)$/.exec(line);
+        if (!scalar) continue;
+        current = scalar[1];
+        const value = unquote(scalar[2]);
+        fields.set(current, value ? value.split(',').map(unquote).filter(Boolean) : []);
+    }
+    return fields;
+}
+
+function escapeRegExp(text: string): string {
+    return text.replace(/[.+^$()|[\]\\]/g, '\\$&');
+}
+
+/** Converts the glob dialect used by `applyTo` (`**`, `*`, `?`, `{a,b}`) into an anchored RegExp. */
+export function globToRegExp(glob: string): RegExp {
+    let pattern = '';
+    for (let index = 0; index < glob.length; index++) {
+        const character = glob[index];
+        if (character === '*') {
+            if (glob[index + 1] === '*') {
+                if (glob[index + 2] === '/') {
+                    pattern += '(?:.*/)?';
+                    index += 2;
+                } else {
+                    pattern += '.*';
+                    index += 1;
+                }
+            } else {
+                pattern += '[^/]*';
+            }
+        } else if (character === '?') {
+            pattern += '[^/]';
+        } else if (character === '{') {
+            const close = glob.indexOf('}', index);
+            if (close > index) {
+                pattern += `(?:${glob.slice(index + 1, close).split(',').map(part => escapeRegExp(part.trim())).join('|')})`;
+                index = close;
+            } else {
+                pattern += '\\{';
+            }
+        } else {
+            pattern += escapeRegExp(character);
+        }
+    }
+    return new RegExp(`^${pattern}$`);
+}
+
+function rulesRoot(cwd: string): string {
     const managedRoot = join(cwd, '.cratis', 'ai', 'rules');
-    const rulesRoot = existsSync(managedRoot) ? managedRoot : join(corpusRoot, 'rules');
-    return readdirSync(rulesRoot, { recursive: true, encoding: 'utf8' })
+    return existsSync(managedRoot) ? managedRoot : join(corpusRoot, 'rules');
+}
+
+function configuration(cwd: string): AiConfiguration | undefined {
+    const path = join(cwd, '.cratis', 'ai.json');
+    if (!existsSync(path)) return undefined;
+    try {
+        return JSON.parse(readFileSync(path, 'utf8')) as AiConfiguration;
+    } catch {
+        return undefined;
+    }
+}
+
+/**
+ * A profile-specific rule is kept only when the repository selects that profile. Repositories without
+ * a `.cratis/ai.json` keep every rule, matching the `@cratis/pi` package.
+ */
+function matchesProfile(rule: ManagedRule, selected: AiConfiguration | undefined): boolean {
+    if (!rule.profile || !selected) return true;
+    const profiles = selected.profiles ?? [];
+    if (rule.profile === 'application') return profiles.some(profile => profile.startsWith('cratis/application'));
+    if (rule.profile === 'framework') return profiles.some(profile => profile.startsWith('cratis/engineering'));
+    return true;
+}
+
+/** Loads every managed rule with its frontmatter interpreted, filtered to the repository's profiles. */
+export function managedRules(cwd: string): ManagedRule[] {
+    const root = rulesRoot(cwd);
+    const selected = configuration(cwd);
+    return readdirSync(root, { recursive: true, encoding: 'utf8' })
         .filter((entry): entry is string => entry.endsWith('.md'))
         .sort()
-        .map(entry => readFileSync(join(rulesRoot, entry), 'utf8'))
-        .join('\n\n');
+        .map(entry => {
+            const content = readFileSync(join(root, entry), 'utf8');
+            const fields = frontmatter(content);
+            return {
+                name: entry.split(sep).join('/'),
+                content,
+                profile: fields.get('profile')?.[0],
+                globs: [...(fields.get('applyTo') ?? []), ...(fields.get('paths') ?? [])],
+            } satisfies ManagedRule;
+        })
+        .filter(rule => matchesProfile(rule, selected));
+}
+
+/** Rules that apply to every file. These belong in the system prompt. */
+export function universalRules(cwd: string): ManagedRule[] {
+    return managedRules(cwd).filter(rule => rule.globs.length === 0 || rule.globs.some(glob => universalGlobs.has(glob)));
+}
+
+/** Rules whose `applyTo`/`paths` match a repository-relative path. These are delivered when that file is touched. */
+export function rulesForPath(cwd: string, relativePath: string): ManagedRule[] {
+    const normalized = relativePath.split(sep).join('/');
+    return managedRules(cwd).filter(rule =>
+        rule.globs.length > 0 &&
+        !rule.globs.some(glob => universalGlobs.has(glob)) &&
+        rule.globs.some(glob => globToRegExp(glob).test(normalized)));
 }
 
-/** Adds every managed Cratis rule to Pi without requiring the @cratis/pi package. */
+/** Upper bound on files considered from one bash command, so a wide command cannot deliver the corpus. */
+const maxPathsPerCommand = 10;
+
+/**
+ * Extracts file paths a bash command refers to. `rtk.md` tells agents to run `rtk read`, `rtk grep`
+ * and `rtk find` from the terminal for bulk reads, so file access frequently arrives as a bash
+ * command rather than the read tool; without this, a session that follows that rule would never
+ * receive a path-scoped rule. A token counts only when it resolves to a file that exists inside the
+ * working directory, which keeps a filename mentioned inside a commit message from matching.
+ */
+function pathsFromCommand(command: string, cwd: string): string[] {
+    const found: string[] = [];
+    for (const raw of command.split(/[\s;|&()<>]+/)) {
+        if (found.length >= maxPathsPerCommand) break;
+        const token = raw.replace(/^['"]+|['"]+$/g, '').replace(/[,:]+$/, '');
+        if (!token || token.startsWith('-') || !/[./]/.test(token)) continue;
+        try {
+            if (statSync(resolve(cwd, token)).isFile()) found.push(token);
+        } catch {
+            /* not a path we can see; ignore */
+        }
+    }
+    return found;
+}
+
+function touchedPaths(toolName: string, input: unknown, cwd: string): string[] {
+    if (toolName === 'bash' || toolName === 'powershell') {
+        const command = (input as { command?: unknown } | undefined)?.command;
+        return typeof command === 'string' ? pathsFromCommand(command, cwd) : [];
+    }
+    if (toolName !== 'read' && toolName !== 'write' && toolName !== 'edit') return [];
+    const candidate = (input as { path?: unknown; file_path?: unknown } | undefined);
+    const value = candidate?.path ?? candidate?.file_path;
+    return typeof value === 'string' && value.length > 0 ? [value] : [];
+}
+
+/**
+ * Gives Pi the same rule semantics as the other harnesses: universal rules in the system prompt, and
+ * path-scoped rules attached the first time a matching file is touched in the session. Without this,
+ * every rule was concatenated into every turn regardless of `applyTo`, `paths`, or `profile`.
+ *
+ * Delivery happens on `tool_result`, so a rule arrives after the call that first touched its file.
+ * `ToolCallEventResult` carries only `block`/`reason`/`terminate`, so there is no supported way to add
+ * context before a tool runs. In practice a file is read before it is edited, and reads through both
+ * the read tool and bash are covered, so the rule is present before the edit; a file created blind by
+ * `write` is the residual case, and it receives the rule with that result.
+ *
+ * A delivered rule lives in the conversation rather than the system prompt, so anything that rewrites
+ * or replaces the conversation can remove it. The delivery record is therefore reset whenever that
+ * happens, and the rule is delivered again the next time one of its files is touched.
+ */
 export default function (pi: ExtensionAPI): void {
+    const delivered = new Set<string>();
+
+    // Compaction summarizes the conversation, which can drop an injected rule while leaving the
+    // delivery record claiming it is present; a switch replaces the conversation outright. Without
+    // this reset a long session would silently lose its scoped rules and never see them again.
+    const reset = () => {
+        delivered.clear();
+    };
+    pi.on('session_start', reset);
+    pi.on('session_compact', reset);
+    pi.on('session_before_switch', reset);
+
     pi.on('before_agent_start', (event, context) => ({
-        systemPrompt: `${event.systemPrompt}\n\n${managedRules(context.cwd)}`,
+        systemPrompt: `${event.systemPrompt}\n\n${universalRules(context.cwd).map(rule => rule.content).join('\n\n')}`,
     }));
+
+    pi.on('tool_result', (event, context) => {
+        if (event.isError) return;
+        const paths = touchedPaths(event.toolName, (event as { input?: unknown }).input, context.cwd);
+        if (paths.length === 0) return;
+        const pending: ManagedRule[] = [];
+        const matched: string[] = [];
+        for (const path of paths) {
+            const relativePath = relative(context.cwd, resolve(context.cwd, path));
+            if (!relativePath || relativePath.startsWith('..')) continue;
+            for (const rule of rulesForPath(context.cwd, relativePath)) {
+                if (delivered.has(rule.name) || pending.some(candidate => candidate.name === rule.name)) continue;
+                pending.push(rule);
+                if (!matched.includes(relativePath)) matched.push(relativePath);
+            }
+        }
+        if (pending.length === 0) return;
+        pending.forEach(rule => delivered.add(rule.name));
+        const existing = Array.isArray(event.content) ? event.content : [];
+        return {
+            content: [
+                ...existing,
+                {
+                    type: 'text',
+                    text: `\n\n[cratis-rules] Rules that apply to ${matched.map(path => path.split(sep).join('/')).join(', ')}:\n\n${pending.map(rule => rule.content).join('\n\n')}`,
+                },
+            ],
+        };
+    });
 }