@shrkcrft/inspector 0.1.0-alpha.30 → 0.1.0-alpha.31

package/dist/role-views.js

@@ -62,10 +62,10 @@ const VIEWS = Object.freeze([
             'shrk architecture map',
             'shrk check boundaries',
             'shrk drift',
-            'shrk intelligence graph',
+            'shrk graph hubs',
             'shrk constructs list',
         ],
-        relevantReports: ['architecture map', 'drift report', 'boundary report', 'intelligence graph'],
+        relevantReports: ['architecture map', 'drift report', 'boundary report', 'code-intelligence graph'],
         relevantRisks: ['Layer violations', 'Public-API drift', 'Untested constructs'],
         suggestedNextAction: 'shrk architecture map --risk',
     },
@@ -92,12 +92,11 @@ const VIEWS = Object.freeze([
         description: 'Safety surface — audit, compliance, policy, MCP no-write.',
         topCommands: [
             'shrk safety audit --deep',
-            'shrk compliance check ai-safe-development',
-            'shrk compliance check signed-pack-workflow',
+            'shrk packs signature-status --release-readiness',
             'shrk policy run --explain-overrides',
             'shrk packs doctor --release --require-signatures',
         ],
-        relevantReports: ['safety audit', 'compliance report', 'policy report'],
+        relevantReports: ['safety audit', 'signature status', 'policy report'],
         relevantRisks: ['MCP write tool introduced', 'Unsigned pack', 'Destructive demo line'],
         suggestedNextAction: 'shrk safety audit --deep',
     },
@@ -108,10 +107,10 @@ const VIEWS = Object.freeze([
         description: 'Agent-facing surface — brief, handoff, MCP tools, forbidden actions.',
         topCommands: [
             'shrk brief "<task>"',
-            'shrk handoff "<task>"',
+            'shrk brief "<task>" --mode handoff',
             'shrk orchestrate "<task>"',
             'shrk simulate "<task>"',
-            'shrk intent "<task>"',
+            'shrk risk "<task>"',
         ],
         relevantReports: ['brief', 'handoff', 'orchestration plan', 'workflow simulation'],
         relevantRisks: ['Auto-apply', 'MCP write attempt', 'Untracked pack command'],
@@ -143,7 +142,8 @@ function buildTaskCommands(role, intent, risk) {
     const t = JSON.stringify(intent.task);
     // Always start with a task brief
     commands.push(`shrk brief ${t}`);
-    commands.push(`shrk intent ${t}`);
+    // The risk report carries the change intent; there is no separate intent verb.
+    commands.push(`shrk risk ${t}`);
     // Per-role + intent
     switch (role) {
         case RoleId.Developer: {
@@ -155,7 +155,7 @@ function buildTaskCommands(role, intent, risk) {
                 commands.push(`shrk tests missing --since main`);
             }
             if (intent.kind === ChangeIntentKind.Bugfix)
-                commands.push('shrk diagnostics suggest "<error text>"');
+                commands.push(`shrk recommend ${t} --from-error <stderr-file>`);
             reports.push('brief', 'task risk', 'impact', 'review packet');
             break;
         }
@@ -170,7 +170,7 @@ function buildTaskCommands(role, intent, risk) {
                 commands.push(`shrk architecture violations`);
             }
             if (intent.domains.includes('plugin') || intent.kind === ChangeIntentKind.Architecture) {
-                commands.push('shrk api report --all --public-only');
+                commands.push('shrk api-diff .sharkcraft/api-baseline.json --fail-on-breaking');
             }
             reports.push('review packet', 'task risk', 'ownership', 'policy', 'architecture violations');
             break;
@@ -178,12 +178,12 @@ function buildTaskCommands(role, intent, risk) {
         case RoleId.Architect: {
             commands.push('shrk architecture map --risk --signals');
             commands.push('shrk architecture violations');
-            commands.push('shrk intelligence graph --include-imports');
+            commands.push('shrk graph hubs');
             commands.push('shrk drift --json');
             if (intent.kind === ChangeIntentKind.Architecture || intent.domains.includes('boundaries')) {
                 commands.push('shrk check boundaries --json');
             }
-            reports.push('architecture map', 'task risk', 'drift report', 'intelligence graph');
+            reports.push('architecture map', 'task risk', 'drift report', 'code-intelligence graph');
             break;
         }
         case RoleId.ReleaseManager: {
@@ -201,17 +201,17 @@ function buildTaskCommands(role, intent, risk) {
         case RoleId.Security: {
             commands.push('shrk safety audit --deep');
             commands.push('shrk policy run --explain-overrides');
-            commands.push('shrk compliance check ai-safe-development');
+            // The compliance verbs were retired; pack signing is checked here.
             if (intent.kind === ChangeIntentKind.Policy || intent.domains.includes('safety')) {
-                commands.push('shrk compliance check signed-pack-workflow');
+                commands.push('shrk packs signature-status --release-readiness');
             }
             if (intent.kind === ChangeIntentKind.Release)
                 commands.push('shrk packs doctor --release --require-signatures');
-            reports.push('safety audit', 'task risk', 'compliance report', 'policy report');
+            reports.push('safety audit', 'task risk', 'signature status', 'policy report');
             break;
         }
         case RoleId.AiAgent: {
-            commands.push(`shrk handoff ${t}`);
+            commands.push(`shrk brief ${t} --mode handoff`);
             commands.push(`shrk orchestrate ${t} --risk-aware`);
             commands.push(`shrk simulate ${t} --mode conservative`);
             commands.push(`shrk recommend ${t}`);

package/dist/routing-recommends-channels.d.ts

@@ -0,0 +1,24 @@
+/**
+ * THE routing-hint `recommends` channel table: every channel a hint may name,
+ * and the registry its ids resolve in.
+ *
+ * One table read by the load lint (an unknown channel key — `pipeline` for
+ * `pipelines` — is reported at load), the self-config doctor (every id probed
+ * through THE id resolver) and `prepareAgentTask` (the resolved non-command
+ * assets it hands the agent). `Record<keyof ITaskRoutingRecommends, …>` makes a
+ * channel added to the public shape without a row here a compile error, so a
+ * channel can never again load, validate, and reach nothing.
+ */
+import type { ITaskRoutingRecommends } from '@shrkcrft/plugin-api';
+import type { ReferenceKind } from './reference-registry.js';
+export declare const ROUTING_RECOMMENDS_CHANNELS: Readonly<Record<keyof ITaskRoutingRecommends, {
+    /** The registry the channel's ids resolve in; `command` goes through the injected command resolver. */
+    readonly kind: ReferenceKind | 'command';
+    /** Singular noun for finding codes and messages (`routing-hint-<label>-missing`). */
+    readonly label: string;
+}>>;
+/** Every channel key, in table order. */
+export declare const ROUTING_RECOMMENDS_CHANNEL_KEYS: readonly (keyof ITaskRoutingRecommends)[];
+/** True when `key` is a channel of the table. */
+export declare function isRoutingRecommendsChannel(key: string): key is keyof ITaskRoutingRecommends;
+//# sourceMappingURL=routing-recommends-channels.d.ts.map

package/dist/routing-recommends-channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-recommends-channels.d.ts","sourceRoot":"","sources":["../src/routing-recommends-channels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAChD,MAAM,CACJ,MAAM,sBAAsB,EAC5B;IACE,uGAAuG;IACvG,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,CAAC;IACzC,qFAAqF;IACrF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CACF,CAaD,CAAC;AAEH,yCAAyC;AACzC,eAAO,MAAM,+BAA+B,EAAE,SAAS,CAAC,MAAM,sBAAsB,CAAC,EAEpF,CAAC;AAEF,iDAAiD;AACjD,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,MAAM,sBAAsB,CAE3F"}

package/dist/routing-recommends-channels.js

@@ -0,0 +1,19 @@
+export const ROUTING_RECOMMENDS_CHANNELS = Object.freeze({
+    commands: { kind: 'command', label: 'command' },
+    templates: { kind: 'template', label: 'template' },
+    playbooks: { kind: 'playbook', label: 'playbook' },
+    helpers: { kind: 'helper', label: 'helper' },
+    profiles: { kind: 'migration-profile', label: 'profile' },
+    conventions: { kind: 'convention', label: 'convention' },
+    knowledge: { kind: 'knowledge', label: 'knowledge' },
+    policies: { kind: 'policy', label: 'policy' },
+    pipelines: { kind: 'pipeline', label: 'pipeline' },
+    rules: { kind: 'rule', label: 'rule' },
+    paths: { kind: 'path-convention', label: 'path' },
+});
+/** Every channel key, in table order. */
+export const ROUTING_RECOMMENDS_CHANNEL_KEYS = Object.freeze(Object.keys(ROUTING_RECOMMENDS_CHANNELS));
+/** True when `key` is a channel of the table. */
+export function isRoutingRecommendsChannel(key) {
+    return Object.prototype.hasOwnProperty.call(ROUTING_RECOMMENDS_CHANNELS, key);
+}

package/dist/run-boundary-check.d.ts

@@ -0,0 +1,118 @@
+import { type IVerdictCoverage } from '@shrkcrft/core';
+import { type IBoundaryRule, type IImportScanResult } from '@shrkcrft/boundaries';
+import type { IRunBoundaryCheckOptions } from './boundary-check-options.model.js';
+import type { IBoundaryCheckResult } from './boundary-check-result.model.js';
+import type { IBoundaryLoadIssue } from './boundary-load-issue.model.js';
+import type { IBoundaryRuleCheck } from './boundary-rule-check.model.js';
+import type { IBoundaryRuleSetDiff } from './boundary-rule-set-diff.model.js';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+/**
+ * THE boundary orchestrator (round 11, C#one-boundary-check-authority).
+ *
+ * `check boundaries`, finish's boundaries gate, `diff-check`, quality and both
+ * MCP boundary tools used to hand-assemble scan + evaluate each — and they
+ * disagreed: the MCP tools never loaded the tsconfig alias map, so an
+ * alias-resolved violation the CLI reported was invisible to an agent. This is
+ * now the only place that:
+ *
+ *   - loads tsconfig paths and builds the known-package list;
+ *   - runs scanImports + evaluateBoundaries;
+ *   - applies the changed-scope filter WITH rule escalation (a rule edit's
+ *     violations are never filed as "legacy");
+ *   - turns load issues into errored rules and stale exceptions into findings;
+ *   - re-settles every rule over what could not be read (`boundaryUnitLiveness`);
+ *   - computes the proposed 0/1/2/3 exit and its coverage, and settles it.
+ *
+ * The CLI builds its gate envelope from `proposedExit` + the coverage records
+ * here (and adds its own `--allow-empty` valve). Both sides settle with core's
+ * `settleVerdict` — ONE fold, not a copy per layer — and
+ * `r75-boundary-parity.test.ts` asserts the envelope's exit equals `exitCode`.
+ */
+export declare function runBoundaryCheck(inspection: ISharkcraftInspection, options?: IRunBoundaryCheckOptions): IBoundaryCheckResult;
+/**
+ * THE "did this selected rule check nothing?" predicate: the engine read no
+ * governed file for it AND no governed file went unread. A rule whose governed
+ * files could not be read matched real files it could not examine — PARTIAL
+ * through its coverage, never listed as "checked nothing" and never a
+ * failOnEmpty failure. Every boundary renderer reads this, not `detail.status`.
+ */
+export declare function boundaryRuleCheckedNothing(r: IBoundaryRuleCheck): boolean;
+/**
+ * THE coverage records a boundary run settles on: the run coverage, each
+ * selected rule's coverage (subject = the rule id) followed by its
+ * `expectEmpty` acceptance (round 13 — folded through core's
+ * `ruleVerdictRecords`, once when the two are the same record), and one record
+ * per errored rule. `runBoundaryCheck` settles with exactly this list, and every
+ * surface that folds a boundary run into its own verdict (drift, `architecture
+ * violations`, the validation loop) reads it too — never a re-derivation.
+ */
+export declare function boundaryCheckCoverage(result: Pick<IBoundaryCheckResult, 'runCoverage' | 'rules' | 'loadIssues'>): IVerdictCoverage[];
+/** The selected rules of a run that checked nothing — {@link boundaryRuleCheckedNothing}, over the whole result. */
+export declare function boundaryRulesCheckedNothing(result: Pick<IBoundaryCheckResult, 'rules'>): IBoundaryRuleCheck[];
+/**
+ * THE "accepted as intended-empty" predicate (round 13, K6): the rule settled
+ * IntendedEmpty — every `from` inclusion marked `expectEmpty`, no file matched,
+ * so it examined 0 files and its coverage IS the acceptance. Read from the
+ * engine's settle (`acceptedAsIntendedEmpty`), never re-derived from a coverage
+ * shape.
+ */
+export declare function boundaryRuleAcceptedEmpty(r: IBoundaryRuleCheck): boolean;
+/** The selected rules accepted as intended-empty — {@link boundaryRuleAcceptedEmpty}, over the whole result. */
+export declare function boundaryRulesAcceptedEmpty(result: Pick<IBoundaryCheckResult, 'rules'>): IBoundaryRuleCheck[];
+/**
+ * THE "rules evaluated" count every boundary surface reports: the selected
+ * rules minus the ones that checked nothing and minus the ones accepted as
+ * intended-empty (round 13 — each examined 0 files; a renderer prints them
+ * apart: `N evaluated, M accepted as intended-empty`, M from
+ * {@link boundaryRulesAcceptedEmpty}). A rule whose governed files went unread
+ * is counted (it is PARTIAL through its coverage, not "checked nothing"); a
+ * failOnEmpty rule that examined nothing is not. `check boundaries --json`,
+ * `diff-check` (CLI + MCP) and MCP `check_boundaries` all read it, so no
+ * surface can re-derive it from `detail.status` and disagree.
+ */
+export declare function boundaryRulesEvaluated(result: Pick<IBoundaryCheckResult, 'rules'>): number;
+/** The `skipped[]` rows of a boundary JSON payload — one shape for the CLI and MCP. */
+export declare function boundarySkippedRuleRows(result: Pick<IBoundaryCheckResult, 'rules'>): {
+    ruleId: string;
+    reason: string;
+    failed: boolean;
+}[];
+/** A label for a load issue — the rule id when known, else `<file>#<index>` / the file. */
+export declare function boundaryLoadIssueLabel(issue: IBoundaryLoadIssue): string;
+/**
+ * The coverage an errored boundary rule carries: one rule asked for, none
+ * examined. Shared by the orchestrator's settle and the CLI envelope's rows.
+ */
+export declare function boundaryLoadIssueCoverage(issue: IBoundaryLoadIssue): IVerdictCoverage;
+/**
+ * Package names the workspace knows: node builtins, the root manifest's
+ * dependency sections, and the name + dependencies of every package.json the
+ * scan walked. A forbidden pattern naming one is resolvable even when nothing
+ * imports it today (a "never adopt X" guard is legitimate).
+ */
+export declare function collectKnownPackages(projectRoot: string, scan: IImportScanResult): string[];
+/**
+ * `check boundaries --diff-against <file>`: what the candidate rule set would
+ * flag, relative to the active one — evaluated by the SAME engine as the gate,
+ * against ONE scan.
+ *
+ * The proposed set is an id overlay: active rules whose id the candidate does
+ * not define, plus every candidate rule (a same id REPLACES, a new id ADDS).
+ * `onlyRuleId` narrows both sides.
+ *
+ * Round 13 (P2): each candidate rule's record goes through the SAME unread
+ * re-settle as `check boundaries` (`boundaryUnitLiveness`) and the same read
+ * scope (`readScopeCoverage`) — an unreadable governed file is never a pass
+ * here either, and a dead unit it could refute is Unproven, not reported.
+ */
+export declare function diffBoundaryRuleSets(inspection: ISharkcraftInspection, candidate: {
+    readonly path: string;
+    readonly rules: readonly IBoundaryRule[];
+    readonly loadIssues?: readonly IBoundaryLoadIssue[];
+}, options?: {
+    readonly onlyRuleId?: string;
+    readonly includeComments?: boolean;
+    /** `--fail-on-dead-units`: a candidate's dead unit, or local went-live marker, makes the proposal 1. */
+    readonly failOnDeadUnits?: boolean;
+}): IBoundaryRuleSetDiff;
+//# sourceMappingURL=run-boundary-check.d.ts.map

package/dist/run-boundary-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-boundary-check.d.ts","sourceRoot":"","sources":["../src/run-boundary-check.ts"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,gBAAgB,EACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAaL,KAAK,aAAa,EAKlB,KAAK,iBAAiB,EAEvB,MAAM,sBAAsB,CAAC;AAK9B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAE7E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAI9E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,qBAAqB,EACjC,OAAO,GAAE,wBAA6B,GACrC,oBAAoB,CA2TtB;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAEzE;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,aAAa,GAAG,OAAO,GAAG,YAAY,CAAC,GACzE,gBAAgB,EAAE,CAQpB;AAED,oHAAoH;AACpH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,OAAO,CAAC,GAAG,kBAAkB,EAAE,CAE7G;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAExE;AAED,gHAAgH;AAChH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,OAAO,CAAC,GAAG,kBAAkB,EAAE,CAE5G;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,OAAO,CAAC,GAAG,MAAM,CAI1F;AAED,uFAAuF;AACvF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,OAAO,CAAC,GAC1C;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,EAAE,CAMvD;AAED,2FAA2F;AAC3F,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAGxE;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,kBAAkB,GAAG,gBAAgB,CAarF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,MAAM,EAAE,CAqB3F;AAUD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,qBAAqB,EACjC,SAAS,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAA;CAAE,EACnI,OAAO,GAAE;IACP,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,wGAAwG;IACxG,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;CAC/B,GACL,oBAAoB,CA+HtB"}