@shrkcrft/inspector 0.1.0-alpha.2

package/dist/review-packet.js

@@ -0,0 +1,129 @@
+import { spawnSync } from 'node:child_process';
+import { evaluateBoundaries, loadTsconfigPaths, scanImports } from '@shrkcrft/boundaries';
+import { rankAll } from "./task-ranker.js";
+function gitDiffFiles(cwd, opts) {
+    if (opts.files && opts.files.length > 0)
+        return [...opts.files];
+    const args = ['diff', '--name-only'];
+    if (opts.staged)
+        args.push('--cached');
+    if (opts.since)
+        args.push(opts.since);
+    const res = spawnSync('git', args, { cwd, encoding: 'utf8' });
+    if (res.status !== 0)
+        return [];
+    return (res.stdout ?? '')
+        .toString()
+        .split('\n')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+function buildPseudoTask(files) {
+    // Use the top-level dir of each file as a pseudo-task description so the
+    // ranker can latch onto path-aware tokens (e.g. "src services").
+    const tokens = new Set();
+    for (const f of files) {
+        for (const seg of f.split('/').slice(0, 4))
+            tokens.add(seg);
+    }
+    return [...tokens].join(' ');
+}
+function missingTestsHeuristic(files) {
+    const out = [];
+    const set = new Set(files);
+    for (const f of files) {
+        if (!f.endsWith('.ts') && !f.endsWith('.tsx'))
+            continue;
+        if (f.includes('/tests/') || f.endsWith('.spec.ts') || f.endsWith('.test.ts'))
+            continue;
+        if (!f.startsWith('src/'))
+            continue;
+        const candidate = f
+            .replace(/^src\//, 'tests/')
+            .replace(/\.tsx?$/, '.spec.ts');
+        if (!set.has(candidate))
+            out.push(`${f} → expected ${candidate}`);
+    }
+    return out;
+}
+export function buildReviewPacket(inspection, options = {}) {
+    const changedFiles = gitDiffFiles(inspection.projectRoot, options);
+    const pseudoTask = buildPseudoTask(changedFiles);
+    const ranking = rankAll(inspection, pseudoTask, 8);
+    // Affected paths: any path-convention whose title or content mentions any
+    // path segment from the changed files.
+    const segments = new Set();
+    for (const f of changedFiles) {
+        for (const seg of f.split('/'))
+            segments.add(seg.toLowerCase());
+    }
+    const affectedPaths = inspection.pathService
+        .list()
+        .filter((p) => [...segments].some((s) => (p.title + ' ' + p.content).toLowerCase().includes(s)))
+        .map((p) => p.id);
+    // Boundary violations restricted to changed files.
+    let boundaryViolations = [];
+    if (inspection.boundaryRegistry.size() > 0 && changedFiles.length > 0) {
+        const scan = scanImports({ projectRoot: inspection.projectRoot });
+        const tsconfigPaths = loadTsconfigPaths(inspection.projectRoot);
+        const evalResult = evaluateBoundaries(scan, inspection.boundaryRegistry.list(), {
+            ...(tsconfigPaths.aliases.size > 0 ? { tsconfigPaths } : {}),
+        });
+        const changedSet = new Set(changedFiles);
+        boundaryViolations = evalResult.violations
+            .filter((v) => changedSet.has(v.file))
+            .map((v) => ({
+            ruleId: v.ruleId,
+            file: v.file,
+            importSpecifier: v.importSpecifier,
+            line: v.line,
+            severity: v.severity,
+            message: v.message,
+        }));
+    }
+    const verificationCommands = unique([
+        'shrk doctor',
+        'shrk check boundaries',
+        'bun x tsc -p tsconfig.base.json --noEmit',
+        'bun test',
+    ]);
+    const reviewerInstructions = [
+        `# AI reviewer instructions`,
+        ``,
+        `This PR touches ${changedFiles.length} file(s).`,
+        `Use the SharkCraft data below to focus your review:`,
+        ``,
+        `1. Confirm the changed files respect the project's path conventions.`,
+        `2. Cross-check the listed rules — anything missing?`,
+        `3. Look at the boundary violations (if any) — those are objective.`,
+        `4. Look at the missing-tests heuristic — is each new src/ file tested?`,
+        `5. Run the verification commands before approving.`,
+        ``,
+        `**Do not write code yourself.** Suggest changes to the human author; the`,
+        `human uses \`shrk apply\` for any writes.`,
+    ].join('\n');
+    return {
+        changedFiles,
+        affectedPaths,
+        relevantRules: ranking.rules.slice(0, 6).map((r) => ({
+            id: r.item.id,
+            title: r.item.title,
+            reason: r.reasons.join('; '),
+        })),
+        relevantTemplates: ranking.templates.slice(0, 6).map((t) => ({
+            id: t.item.id,
+            name: t.item.name,
+        })),
+        relevantPipelines: ranking.pipelines.slice(0, 3).map((p) => ({
+            id: p.item.id,
+            title: p.item.title,
+        })),
+        boundaryViolations,
+        missingTestsHeuristic: missingTestsHeuristic(changedFiles),
+        verificationCommands,
+        reviewerInstructions,
+    };
+}
+function unique(xs) {
+    return [...new Set(xs)];
+}

package/dist/risk-signals.d.ts

@@ -0,0 +1,28 @@
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const RISK_SIGNALS_SCHEMA = "sharkcraft.risk-signals/v1";
+export declare enum RiskLevel {
+    Low = "low",
+    Medium = "medium",
+    High = "high",
+    Critical = "critical"
+}
+export interface IRiskSignals {
+    schema: typeof RISK_SIGNALS_SCHEMA;
+    generatedAt: string;
+    level: RiskLevel;
+    reasons: readonly string[];
+    inputs: {
+        boundaryViolationErrors: number;
+        boundaryViolationWarnings: number;
+        architectureRisks: number;
+        hasPacks: boolean;
+        packsUnsignedOrInvalid: number;
+        testsDetected: number;
+        ownershipDetected: number;
+        fileListTruncated: boolean;
+    };
+}
+export declare function computeRiskSignals(inspection: ISharkcraftInspection, options?: {
+    withSignals?: boolean;
+}): Promise<IRiskSignals>;
+//# sourceMappingURL=risk-signals.d.ts.map

package/dist/risk-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"risk-signals.d.ts","sourceRoot":"","sources":["../src/risk-signals.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE,eAAO,MAAM,mBAAmB,+BAA+B,CAAC;AAEhE,oBAAY,SAAS;IACnB,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,QAAQ,aAAa;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,OAAO,mBAAmB,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,MAAM,EAAE;QACN,uBAAuB,EAAE,MAAM,CAAC;QAChC,yBAAyB,EAAE,MAAM,CAAC;QAClC,iBAAiB,EAAE,MAAM,CAAC;QAC1B,QAAQ,EAAE,OAAO,CAAC;QAClB,sBAAsB,EAAE,MAAM,CAAC;QAC/B,aAAa,EAAE,MAAM,CAAC;QACtB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,iBAAiB,EAAE,OAAO,CAAC;KAC5B,CAAC;CACH;AAED,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,qBAAqB,EACjC,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,GACtC,OAAO,CAAC,YAAY,CAAC,CAkDvB"}

package/dist/risk-signals.js

@@ -0,0 +1,68 @@
+/**
+ * Risk-signal aggregator.
+ *
+ * Centralised, deterministic source of risk inputs used by orchestration,
+ * simulation, role views and the recommender. Read-only.
+ */
+import { buildArchitectureMap } from "./architecture-map.js";
+export const RISK_SIGNALS_SCHEMA = 'sharkcraft.risk-signals/v1';
+export var RiskLevel;
+(function (RiskLevel) {
+    RiskLevel["Low"] = "low";
+    RiskLevel["Medium"] = "medium";
+    RiskLevel["High"] = "high";
+    RiskLevel["Critical"] = "critical";
+})(RiskLevel || (RiskLevel = {}));
+export async function computeRiskSignals(inspection, options = {}) {
+    const map = await buildArchitectureMap(inspection, { signals: options.withSignals ?? true });
+    const validPacks = inspection.packs.validPacks ?? [];
+    const packsUnsignedOrInvalid = validPacks.filter((p) => p.signatureStatus === 'invalid-signature' || p.signatureStatus === 'missing-signature').length;
+    const inputs = {
+        boundaryViolationErrors: map.boundaryViolationCounts.error,
+        boundaryViolationWarnings: map.boundaryViolationCounts.warning,
+        architectureRisks: map.risks.length,
+        hasPacks: validPacks.length > 0,
+        packsUnsignedOrInvalid,
+        testsDetected: map.graphSummary.tests,
+        ownershipDetected: map.graphSummary.ownership,
+        fileListTruncated: false,
+    };
+    const reasons = [];
+    let score = 0;
+    if (inputs.boundaryViolationErrors > 0) {
+        score += 3;
+        reasons.push(`${inputs.boundaryViolationErrors} boundary violation(s) at error severity.`);
+    }
+    if (inputs.boundaryViolationWarnings > 0) {
+        score += 1;
+        reasons.push(`${inputs.boundaryViolationWarnings} boundary violation(s) at warning severity.`);
+    }
+    if (inputs.architectureRisks > 0) {
+        score += 1;
+        reasons.push(`${inputs.architectureRisks} architecture risk finding(s).`);
+    }
+    if (inputs.packsUnsignedOrInvalid > 0) {
+        score += 2;
+        reasons.push(`${inputs.packsUnsignedOrInvalid} pack(s) with invalid/missing signature.`);
+    }
+    if (inputs.testsDetected === 0) {
+        score += 2;
+        reasons.push('No tests detected.');
+    }
+    let level = RiskLevel.Low;
+    if (score >= 5)
+        level = RiskLevel.Critical;
+    else if (score >= 3)
+        level = RiskLevel.High;
+    else if (score >= 1)
+        level = RiskLevel.Medium;
+    if (reasons.length === 0)
+        reasons.push('No elevated risk signals detected.');
+    return {
+        schema: RISK_SIGNALS_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        level,
+        reasons,
+        inputs,
+    };
+}

package/dist/role-views.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Role-specific views.
+ * Task-aware extension — when a task is supplied, the view is
+ * personalised using intent classification + task risk + intent's
+ * suggested first command. No AI; deterministic.
+ *
+ * Read-only.
+ */
+import { ChangeIntentKind } from './change-intent.js';
+import { TaskRiskLevel } from './task-risk.js';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const ROLE_VIEW_SCHEMA = "sharkcraft.role-view/v1";
+export declare enum RoleId {
+    Developer = "developer",
+    Reviewer = "reviewer",
+    Architect = "architect",
+    ReleaseManager = "release-manager",
+    Security = "security",
+    AiAgent = "ai-agent"
+}
+export interface IRoleView {
+    schema: typeof ROLE_VIEW_SCHEMA;
+    role: RoleId;
+    title: string;
+    description: string;
+    topCommands: readonly string[];
+    relevantReports: readonly string[];
+    relevantRisks: readonly string[];
+    suggestedNextAction: string;
+}
+export interface IRoleViewTaskSpecific {
+    task: string;
+    intentKind: ChangeIntentKind;
+    intentConfidence: string;
+    taskRiskLevel: TaskRiskLevel;
+    taskCommands: readonly string[];
+    taskRisks: readonly string[];
+    taskReports: readonly string[];
+    whatNotToDo: readonly string[];
+    nextSafeAction: string;
+    humanApprovalPoints: readonly string[];
+}
+export interface ITaskAwareRoleView extends IRoleView {
+    taskSpecific?: IRoleViewTaskSpecific;
+}
+export declare function listRoleViews(): readonly IRoleView[];
+export declare function getRoleView(role: string): IRoleView | undefined;
+export declare function getTaskAwareRoleView(role: string, task: string, inspection: ISharkcraftInspection): Promise<ITaskAwareRoleView | undefined>;
+export declare function renderTaskAwareRoleViewText(v: ITaskAwareRoleView): string;
+//# sourceMappingURL=role-views.d.ts.map

package/dist/role-views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role-views.d.ts","sourceRoot":"","sources":["../src/role-views.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAwB,gBAAgB,EAAsB,MAAM,oBAAoB,CAAC;AAChG,OAAO,EAAuB,aAAa,EAAwB,MAAM,gBAAgB,CAAC;AAC1F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE,eAAO,MAAM,gBAAgB,4BAA4B,CAAC;AAE1D,oBAAY,MAAM;IAChB,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,cAAc,oBAAoB;IAClC,QAAQ,aAAa;IACrB,OAAO,aAAa;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,OAAO,gBAAgB,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,gBAAgB,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED,MAAM,WAAW,kBAAmB,SAAQ,SAAS;IACnD,YAAY,CAAC,EAAE,qBAAqB,CAAC;CACtC;AAuGD,wBAAgB,aAAa,IAAI,SAAS,SAAS,EAAE,CAEpD;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE/D;AA4ID,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,qBAAqB,GAChC,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC,CA8BzC;AAED,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAqCzE"}

package/dist/role-views.js

@@ -0,0 +1,334 @@
+/**
+ * Role-specific views.
+ * Task-aware extension — when a task is supplied, the view is
+ * personalised using intent classification + task risk + intent's
+ * suggested first command. No AI; deterministic.
+ *
+ * Read-only.
+ */
+import { classifyChangeIntent, ChangeIntentKind } from "./change-intent.js";
+import { buildTaskRiskReport, TaskRiskLevel } from "./task-risk.js";
+export const ROLE_VIEW_SCHEMA = 'sharkcraft.role-view/v1';
+export var RoleId;
+(function (RoleId) {
+    RoleId["Developer"] = "developer";
+    RoleId["Reviewer"] = "reviewer";
+    RoleId["Architect"] = "architect";
+    RoleId["ReleaseManager"] = "release-manager";
+    RoleId["Security"] = "security";
+    RoleId["AiAgent"] = "ai-agent";
+})(RoleId || (RoleId = {}));
+const VIEWS = Object.freeze([
+    {
+        schema: ROLE_VIEW_SCHEMA,
+        role: RoleId.Developer,
+        title: 'Developer',
+        description: 'Daily work loop — brief, dev session, plan, apply, validate.',
+        topCommands: [
+            'shrk brief "<task>"',
+            'shrk dev start "<task>"',
+            'shrk gen <templateId> <name> --dry-run --save-plan /tmp/plan.json',
+            'shrk plan review /tmp/plan.json',
+            'shrk apply /tmp/plan.json --verify-signature --validate',
+            'shrk impact --since main',
+            'shrk tests missing --since main',
+        ],
+        relevantReports: ['brief', 'impact', 'review packet', 'dev session report'],
+        relevantRisks: ['Forgotten dry-run', 'Apply without --verify-signature'],
+        suggestedNextAction: 'shrk brief "<your next task>"',
+    },
+    {
+        schema: ROLE_VIEW_SCHEMA,
+        role: RoleId.Reviewer,
+        title: 'Reviewer',
+        description: 'PR review surface — impact, ownership, policy, review packet.',
+        topCommands: [
+            'shrk review packet --v3 --since main',
+            'shrk impact --since main',
+            'shrk owners impact --since main',
+            'shrk policy run',
+            'shrk report site --output /tmp/site',
+        ],
+        relevantReports: ['review packet', 'impact', 'ownership', 'policy', 'report site'],
+        relevantRisks: ['Hidden boundary change', 'Missing owners', 'Policy override without reason'],
+        suggestedNextAction: 'shrk review packet --v3 --since main',
+    },
+    {
+        schema: ROLE_VIEW_SCHEMA,
+        role: RoleId.Architect,
+        title: 'Architect',
+        description: 'Architecture surface — map, boundaries, drift, constructs.',
+        topCommands: [
+            'shrk architecture map',
+            'shrk check boundaries',
+            'shrk drift',
+            'shrk intelligence graph',
+            'shrk constructs list',
+        ],
+        relevantReports: ['architecture map', 'drift report', 'boundary report', 'intelligence graph'],
+        relevantRisks: ['Layer violations', 'Public-API drift', 'Untested constructs'],
+        suggestedNextAction: 'shrk architecture map --risk',
+    },
+    {
+        schema: ROLE_VIEW_SCHEMA,
+        role: RoleId.ReleaseManager,
+        title: 'Release manager',
+        description: 'Release surface — readiness, smoke, preflight, changelog.',
+        topCommands: [
+            'shrk release readiness --strict',
+            'shrk release smoke --scenario all',
+            'shrk release smoke --matrix',
+            'bun run release:preflight',
+            'shrk install smoke --tarball',
+        ],
+        relevantReports: ['release readiness', 'release smoke', 'preflight'],
+        relevantRisks: ['Stale preflight summary', 'Smoke regression', 'Tarball install failure'],
+        suggestedNextAction: 'shrk release readiness --strict',
+    },
+    {
+        schema: ROLE_VIEW_SCHEMA,
+        role: RoleId.Security,
+        title: 'Security',
+        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 policy run --explain-overrides',
+            'shrk packs doctor --release --require-signatures',
+        ],
+        relevantReports: ['safety audit', 'compliance report', 'policy report'],
+        relevantRisks: ['MCP write tool introduced', 'Unsigned pack', 'Destructive demo line'],
+        suggestedNextAction: 'shrk safety audit --deep',
+    },
+    {
+        schema: ROLE_VIEW_SCHEMA,
+        role: RoleId.AiAgent,
+        title: 'AI agent',
+        description: 'Agent-facing surface — brief, handoff, MCP tools, forbidden actions.',
+        topCommands: [
+            'shrk brief "<task>"',
+            'shrk handoff "<task>"',
+            'shrk orchestrate "<task>"',
+            'shrk simulate "<task>"',
+            'shrk intent "<task>"',
+        ],
+        relevantReports: ['brief', 'handoff', 'orchestration plan', 'workflow simulation'],
+        relevantRisks: ['Auto-apply', 'MCP write attempt', 'Untracked pack command'],
+        suggestedNextAction: 'shrk start-here',
+    },
+]);
+export function listRoleViews() {
+    return VIEWS;
+}
+export function getRoleView(role) {
+    return VIEWS.find((v) => v.role === role);
+}
+const FORBIDDEN_FOR_RELEASE = Object.freeze([
+    'Do not publish or tag without explicit human approval.',
+    'Do not skip preflight gates.',
+]);
+const FORBIDDEN_FOR_AI = Object.freeze([
+    'Do not call MCP write tools — MCP is read-only.',
+    'Do not run `shrk apply` from MCP.',
+    'Do not auto-apply plans.',
+    'Do not execute pack-contributed verification commands without explicit local opt-in.',
+]);
+function buildTaskCommands(role, intent, risk) {
+    const commands = [];
+    const risks = [];
+    const reports = [];
+    const forbidden = [];
+    const approvalPoints = [];
+    const t = JSON.stringify(intent.task);
+    // Always start with a task brief
+    commands.push(`shrk brief ${t}`);
+    commands.push(`shrk intent ${t}`);
+    // Per-role + intent
+    switch (role) {
+        case RoleId.Developer: {
+            commands.push(`shrk dev start ${t}`);
+            commands.push(`shrk gen <templateId> <name> --dry-run --save-plan /tmp/plan.json`);
+            commands.push(`shrk plan review /tmp/plan.json`);
+            if (intent.kind !== ChangeIntentKind.Docs) {
+                commands.push(`shrk impact --since main`);
+                commands.push(`shrk tests missing --since main`);
+            }
+            if (intent.kind === ChangeIntentKind.Bugfix)
+                commands.push('shrk diagnostics suggest "<error text>"');
+            reports.push('brief', 'task risk', 'impact', 'review packet');
+            break;
+        }
+        case RoleId.Reviewer: {
+            commands.push(`shrk review packet --v3 --since main`);
+            commands.push(`shrk impact --since main`);
+            commands.push(`shrk owners impact --since main`);
+            commands.push(`shrk policy run --explain-overrides`);
+            if (intent.kind === ChangeIntentKind.Architecture ||
+                intent.domains.includes('boundaries') ||
+                intent.domains.includes('plugin')) {
+                commands.push(`shrk architecture violations`);
+            }
+            if (intent.domains.includes('plugin') || intent.kind === ChangeIntentKind.Architecture) {
+                commands.push('shrk api report --all --public-only');
+            }
+            reports.push('review packet', 'task risk', 'ownership', 'policy', 'architecture violations');
+            break;
+        }
+        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 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');
+            break;
+        }
+        case RoleId.ReleaseManager: {
+            commands.push('shrk release readiness --strict');
+            commands.push('shrk release smoke --scenario all');
+            commands.push('shrk release smoke --matrix');
+            commands.push('bun run release:preflight');
+            if (intent.kind === ChangeIntentKind.Release)
+                commands.push('shrk install smoke --tarball');
+            reports.push('release readiness', 'release smoke', 'task risk', 'preflight');
+            for (const f of FORBIDDEN_FOR_RELEASE)
+                forbidden.push(f);
+            break;
+        }
+        case RoleId.Security: {
+            commands.push('shrk safety audit --deep');
+            commands.push('shrk policy run --explain-overrides');
+            commands.push('shrk compliance check ai-safe-development');
+            if (intent.kind === ChangeIntentKind.Policy || intent.domains.includes('safety')) {
+                commands.push('shrk compliance check signed-pack-workflow');
+            }
+            if (intent.kind === ChangeIntentKind.Release)
+                commands.push('shrk packs doctor --release --require-signatures');
+            reports.push('safety audit', 'task risk', 'compliance report', 'policy report');
+            break;
+        }
+        case RoleId.AiAgent: {
+            commands.push(`shrk handoff ${t}`);
+            commands.push(`shrk orchestrate ${t} --risk-aware`);
+            commands.push(`shrk simulate ${t} --mode conservative`);
+            commands.push(`shrk recommend ${t}`);
+            reports.push('brief', 'handoff', 'orchestration plan', 'task risk', 'workflow simulation');
+            for (const f of FORBIDDEN_FOR_AI)
+                forbidden.push(f);
+            break;
+        }
+    }
+    // Risk-driven extras
+    if (risk.riskLevel === TaskRiskLevel.High || risk.riskLevel === TaskRiskLevel.Critical) {
+        commands.push('shrk risk "' + intent.task + '" --explain');
+        commands.push('shrk architecture map --risk --signals');
+        commands.push('shrk policy run --explain-overrides');
+        risks.push(`Task risk level is ${risk.riskLevel} (score ${risk.score}).`);
+        approvalPoints.push('Risk review: a human must approve before any write step.');
+    }
+    for (const r of risk.reasons.slice(0, 5)) {
+        risks.push(`[${r.code}] ${r.message}`);
+    }
+    for (const c of risk.boundaryConcerns)
+        risks.push(c);
+    for (const c of risk.policyConcerns)
+        risks.push(c);
+    for (const f of risk.ownershipGaps)
+        risks.push(`Ownership gap: ${f}`);
+    // Intent-required review
+    if (intent.requiredHumanReview) {
+        approvalPoints.push('Intent flagged as requiring human review.');
+    }
+    // Universal forbidden for AI/agent contexts when intent is release
+    if (intent.kind === ChangeIntentKind.Release) {
+        forbidden.push('Do not run a publish step without explicit human approval.');
+        forbidden.push('Do not push tags from MCP.');
+    }
+    return {
+        commands: [...new Set(commands)],
+        risks: [...new Set(risks)],
+        reports: [...new Set(reports)],
+        forbidden: [...new Set(forbidden)],
+        approvalPoints: [...new Set(approvalPoints)],
+    };
+}
+export async function getTaskAwareRoleView(role, task, inspection) {
+    const base = getRoleView(role);
+    if (!base)
+        return undefined;
+    const trimmed = task.trim();
+    if (!trimmed)
+        return { ...base };
+    const intent = await classifyChangeIntent(trimmed, inspection);
+    let risk;
+    try {
+        risk = await buildTaskRiskReport(trimmed, inspection, { includeMemory: true });
+    }
+    catch {
+        return { ...base };
+    }
+    const composed = buildTaskCommands(base.role, intent, risk);
+    const nextSafeAction = composed.commands[0] ?? intent.suggestedFirstCommand ?? base.suggestedNextAction;
+    return {
+        ...base,
+        taskSpecific: {
+            task: trimmed,
+            intentKind: intent.kind,
+            intentConfidence: intent.confidence,
+            taskRiskLevel: risk.riskLevel,
+            taskCommands: composed.commands.slice(0, 10),
+            taskRisks: composed.risks.slice(0, 10),
+            taskReports: composed.reports.slice(0, 10),
+            whatNotToDo: composed.forbidden,
+            nextSafeAction,
+            humanApprovalPoints: composed.approvalPoints,
+        },
+    };
+}
+export function renderTaskAwareRoleViewText(v) {
+    const lines = [];
+    lines.push(`=== Role view: ${v.title} ===`);
+    lines.push(`  description     ${v.description}`);
+    if (v.taskSpecific) {
+        const t = v.taskSpecific;
+        lines.push('');
+        lines.push('--- Task-specific ---');
+        lines.push(`  task            ${t.task}`);
+        lines.push(`  intent          ${t.intentKind} (confidence ${t.intentConfidence})`);
+        lines.push(`  task risk       ${t.taskRiskLevel}`);
+        lines.push(`  next safe       ${t.nextSafeAction}`);
+        if (t.taskCommands.length > 0) {
+            lines.push('Top task commands:');
+            for (const c of t.taskCommands)
+                lines.push(`  $ ${c}`);
+        }
+        if (t.taskRisks.length > 0) {
+            lines.push('Task risks:');
+            for (const r of t.taskRisks)
+                lines.push(`  • ${r}`);
+        }
+        if (t.taskReports.length > 0) {
+            lines.push('Reports to consult: ' + t.taskReports.join(', '));
+        }
+        if (t.whatNotToDo.length > 0) {
+            lines.push('What NOT to do:');
+            for (const f of t.whatNotToDo)
+                lines.push(`  • ${f}`);
+        }
+        if (t.humanApprovalPoints.length > 0) {
+            lines.push('Human approval points:');
+            for (const a of t.humanApprovalPoints)
+                lines.push(`  • ${a}`);
+        }
+    }
+    else {
+        lines.push('Top commands:');
+        for (const c of v.topCommands)
+            lines.push(`  $ ${c}`);
+        lines.push(`Suggested next: ${v.suggestedNextAction}`);
+    }
+    return lines.join('\n') + '\n';
+}

package/dist/rounds.d.ts

@@ -0,0 +1,52 @@
+export declare const ROUND_SNAPSHOT_SCHEMA = "sharkcraft.round-snapshot/v1";
+export declare const ROUNDS_DIFF_SCHEMA = "sharkcraft.rounds-diff/v1";
+export interface IRoundCommandEntry {
+    name: string;
+    description: string;
+}
+export interface IRoundToolEntry {
+    name: string;
+    description: string;
+}
+export interface IRoundMeta {
+    id: string;
+    title?: string;
+    capturedAt: string;
+}
+export interface IRoundSnapshot {
+    schema: typeof ROUND_SNAPSHOT_SCHEMA;
+    id: string;
+    title?: string;
+    capturedAt: string;
+    commands: readonly IRoundCommandEntry[];
+    mcpTools: readonly IRoundToolEntry[];
+    docs: readonly string[];
+}
+export interface IRoundsDiff {
+    schema: typeof ROUNDS_DIFF_SCHEMA;
+    fromId: string;
+    toId: string;
+    commandsAdded: readonly IRoundCommandEntry[];
+    commandsRemoved: readonly IRoundCommandEntry[];
+    mcpToolsAdded: readonly IRoundToolEntry[];
+    mcpToolsRemoved: readonly IRoundToolEntry[];
+    docsAdded: readonly string[];
+    docsRemoved: readonly string[];
+}
+export interface ICaptureInput {
+    projectRoot: string;
+    id: string;
+    title?: string;
+    commands: readonly IRoundCommandEntry[];
+    mcpTools: readonly IRoundToolEntry[];
+}
+export declare function captureRoundSnapshot(input: ICaptureInput): IRoundSnapshot;
+export declare function writeRoundSnapshot(projectRoot: string, snapshot: IRoundSnapshot): {
+    snapshotFile: string;
+    metaFile: string;
+};
+export declare function loadRoundSnapshot(projectRoot: string, id: string): IRoundSnapshot | null;
+export declare function listRoundIds(projectRoot: string): readonly string[];
+export declare function diffRounds(fromSnapshot: IRoundSnapshot, toSnapshot: IRoundSnapshot): IRoundsDiff;
+export declare function renderRoundsDiffMarkdown(diff: IRoundsDiff): string;
+//# sourceMappingURL=rounds.d.ts.map

package/dist/rounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rounds.d.ts","sourceRoot":"","sources":["../src/rounds.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,qBAAqB,iCAAiC,CAAC;AACpE,eAAO,MAAM,kBAAkB,8BAA8B,CAAC;AAE9D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,qBAAqB,CAAC;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACxC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;IACrC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,OAAO,kBAAkB,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC7C,eAAe,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC/C,aAAa,EAAE,SAAS,eAAe,EAAE,CAAC;IAC1C,eAAe,EAAE,SAAS,eAAe,EAAE,CAAC;IAC5C,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACxC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;CACtC;AA2BD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,CAWzE;AAED,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,cAAc,GACvB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAa5C;AAED,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,MAAM,GACT,cAAc,GAAG,IAAI,CAQvB;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAYnE;AA0BD,wBAAgB,UAAU,CACxB,YAAY,EAAE,cAAc,EAC5B,UAAU,EAAE,cAAc,GACzB,WAAW,CAeb;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CA+BlE"}