instar 0.28.117 → 0.28.119

package/dist/monitoring/FrameworkParitySentinel.d.ts

@@ -0,0 +1,91 @@
+/**
+ * FrameworkParitySentinel — consumer of the Layer-3 parity rules registry.
+ *
+ * Spec: specs/instar-foundations/framework-parity-sentinel.md
+ *
+ * Walks the registry on its scan cadence (and on triggers), calls each rule's
+ * verify() per instance, surfaces drift via events + degradation reports, and
+ * (per rule's remediationPolicy) optionally calls remediate() to re-render
+ * canonical into the framework-native shape.
+ *
+ * v0.1 scope:
+ *   - Registry walker (consume listParityRules → iterate → collect verify).
+ *   - State file persistence (.instar/state/framework-parity-sentinel.json).
+ *   - Interval trigger (single setInterval; no chokidar watcher yet).
+ *   - EventEmitter wiring (5 events: gap-found, remediated, remediation-refused,
+ *     orphan-found, scan-complete).
+ *   - Degradation reporter on persistent unresolved gaps.
+ *
+ * v0.2 deferred: chokidar source-change watcher, per-instance remediate HTTP
+ * route, trust-level integration for mirror-trust gating, backfill migration.
+ */
+import { EventEmitter } from 'node:events';
+import { getParityRule } from '../providers/parity/registry.js';
+import type { IntelligenceFramework } from '../core/intelligenceProviderFactory.js';
+export interface FrameworkParitySentinelConfig {
+    /** Project root (passed to each rule's verify/remediate). */
+    projectRoot: string;
+    /** State directory (typically `.instar`). */
+    stateDir: string;
+    /** Which frameworks are currently enabled for this agent. */
+    enabledFrameworks: ReadonlyArray<IntelligenceFramework>;
+    /** Scan interval in ms. Default: 1_800_000 (30 min). */
+    scanIntervalMs?: number;
+    /** Initial scan delay in ms. Default: 60_000 (1 min after start). */
+    initialScanDelayMs?: number;
+    /** If true, mirror-trust rules call remediate(); if false, all rules are flag-only. */
+    remediationEnabled?: boolean;
+}
+interface PerInstanceCursor {
+    lastScanAt: string;
+    lastResult: 'ok' | 'drift' | 'conflict' | 'error';
+    lastDetail?: string;
+    /** Number of consecutive scans with unresolved drift — used for degradation reporting. */
+    unresolvedCount: number;
+}
+export interface ParityScanReport {
+    scannedAt: string;
+    rulesWalked: number;
+    instancesChecked: number;
+    gapsFound: number;
+    remediated: number;
+    remediationRefused: number;
+    orphansFound: number;
+}
+export declare class FrameworkParitySentinel extends EventEmitter {
+    private config;
+    private state;
+    private statePath;
+    private interval;
+    private initialTimeout;
+    private isScanning;
+    constructor(config: FrameworkParitySentinelConfig);
+    start(): void;
+    stop(): void;
+    /**
+     * Run a full scan immediately. Returns a structured report. Safe to call
+     * concurrently — overlapping calls are short-circuited.
+     */
+    scan(): Promise<ParityScanReport>;
+    /**
+     * Returns the current scan state — used by the HTTP /api/framework-parity/status route.
+     */
+    getStatus(): {
+        lastScanAt: string | null;
+        cursors: Record<string, PerInstanceCursor>;
+    };
+    private scanRule;
+    private attemptRemediate;
+    private shouldRemediate;
+    private recordRuleError;
+    private loadState;
+    private saveState;
+}
+/**
+ * Lookup a single rule by primitive. Re-exported here so the sentinel's
+ * tests and the HTTP routes have a single import surface.
+ * @internal
+ */
+export declare const _getParityRuleForTest: typeof getParityRule;
+export {};
+//# sourceMappingURL=FrameworkParitySentinel.d.ts.map

package/dist/monitoring/FrameworkParitySentinel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrameworkParitySentinel.d.ts","sourceRoot":"","sources":["../../src/monitoring/FrameworkParitySentinel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,EAEL,aAAa,EACd,MAAM,iCAAiC,CAAC;AAMzC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAKpF,MAAM,WAAW,6BAA6B;IAC5C,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,iBAAiB,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;IACxD,wDAAwD;IACxD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,uFAAuF;IACvF,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,UAAU,iBAAiB;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,IAAI,GAAG,OAAO,GAAG,UAAU,GAAG,OAAO,CAAC;IAClD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0FAA0F;IAC1F,eAAe,EAAE,MAAM,CAAC;CACzB;AASD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC;CACtB;AAUD,qBAAa,uBAAwB,SAAQ,YAAY;IACvD,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAA+C;IAC/D,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,UAAU,CAAS;gBAEf,MAAM,EAAE,6BAA6B;IASjD,KAAK,IAAI,IAAI;IAsBb,IAAI,IAAI,IAAI;IAaZ;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAkDvC;;OAEG;IACH,SAAS,IAAI;QAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;KAAE;YASxE,QAAQ;YAiFR,gBAAgB;IA4B9B,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,eAAe;IAcvB,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,SAAS;CAWlB;AAID;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,sBAAgB,CAAC"}

package/dist/monitoring/FrameworkParitySentinel.js

@@ -0,0 +1,286 @@
+/**
+ * FrameworkParitySentinel — consumer of the Layer-3 parity rules registry.
+ *
+ * Spec: specs/instar-foundations/framework-parity-sentinel.md
+ *
+ * Walks the registry on its scan cadence (and on triggers), calls each rule's
+ * verify() per instance, surfaces drift via events + degradation reports, and
+ * (per rule's remediationPolicy) optionally calls remediate() to re-render
+ * canonical into the framework-native shape.
+ *
+ * v0.1 scope:
+ *   - Registry walker (consume listParityRules → iterate → collect verify).
+ *   - State file persistence (.instar/state/framework-parity-sentinel.json).
+ *   - Interval trigger (single setInterval; no chokidar watcher yet).
+ *   - EventEmitter wiring (5 events: gap-found, remediated, remediation-refused,
+ *     orphan-found, scan-complete).
+ *   - Degradation reporter on persistent unresolved gaps.
+ *
+ * v0.2 deferred: chokidar source-change watcher, per-instance remediate HTTP
+ * route, trust-level integration for mirror-trust gating, backfill migration.
+ */
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import path from 'node:path';
+import { listParityRules, getParityRule, } from '../providers/parity/registry.js';
+import { DegradationReporter } from './DegradationReporter.js';
+// ── Helpers ───────────────────────────────────────────────────────
+function cursorKey(primitive, instance) {
+    return `${primitive}::${instance}`;
+}
+// ── Implementation ────────────────────────────────────────────────
+export class FrameworkParitySentinel extends EventEmitter {
+    config;
+    state;
+    statePath;
+    interval = null;
+    initialTimeout = null;
+    isScanning = false;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.statePath = path.join(config.stateDir, 'state', 'framework-parity-sentinel.json');
+        this.state = this.loadState();
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────
+    start() {
+        if (this.interval)
+            return;
+        const intervalMs = this.config.scanIntervalMs ?? 1_800_000;
+        const initialDelay = this.config.initialScanDelayMs ?? 60_000;
+        this.initialTimeout = setTimeout(() => {
+            void this.scan();
+        }, initialDelay);
+        this.initialTimeout.unref?.();
+        this.interval = setInterval(() => {
+            void this.scan();
+        }, intervalMs);
+        this.interval.unref?.();
+        console.log(`[FrameworkParitySentinel] started — interval ${Math.round(intervalMs / 60_000)}m, ` +
+            `first scan in ${Math.round(initialDelay / 1000)}s`);
+    }
+    stop() {
+        if (this.initialTimeout) {
+            clearTimeout(this.initialTimeout);
+            this.initialTimeout = null;
+        }
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    // ── Public API ─────────────────────────────────────────────────
+    /**
+     * Run a full scan immediately. Returns a structured report. Safe to call
+     * concurrently — overlapping calls are short-circuited.
+     */
+    async scan() {
+        if (this.isScanning) {
+            return {
+                scannedAt: new Date().toISOString(),
+                rulesWalked: 0,
+                instancesChecked: 0,
+                gapsFound: 0,
+                remediated: 0,
+                remediationRefused: 0,
+                orphansFound: 0,
+            };
+        }
+        this.isScanning = true;
+        const scannedAt = new Date().toISOString();
+        const report = {
+            scannedAt,
+            rulesWalked: 0,
+            instancesChecked: 0,
+            gapsFound: 0,
+            remediated: 0,
+            remediationRefused: 0,
+            orphansFound: 0,
+        };
+        try {
+            const rules = listParityRules();
+            for (const rule of rules) {
+                report.rulesWalked += 1;
+                await this.scanRule(rule, report);
+            }
+            this.state.lastScanAt = scannedAt;
+            this.saveState();
+            this.emit('parity:scan-complete', report);
+            return report;
+        }
+        catch (err) {
+            DegradationReporter.getInstance().report({
+                feature: 'FrameworkParitySentinel.scan',
+                primary: 'Walk parity rules registry + verify',
+                fallback: 'Scan aborted; cursors not advanced',
+                reason: `Scan error: ${err instanceof Error ? err.message : String(err)}`,
+                impact: 'Cross-framework drift may go undetected until next successful scan',
+            });
+            console.error('[FrameworkParitySentinel] scan error:', err);
+            return report;
+        }
+        finally {
+            this.isScanning = false;
+        }
+    }
+    /**
+     * Returns the current scan state — used by the HTTP /api/framework-parity/status route.
+     */
+    getStatus() {
+        return {
+            lastScanAt: this.state.lastScanAt,
+            cursors: { ...this.state.cursors },
+        };
+    }
+    // ── Scan implementation ────────────────────────────────────────
+    async scanRule(rule, report) {
+        let instances;
+        try {
+            instances = await rule.listInstances(this.config.projectRoot);
+        }
+        catch (err) {
+            this.recordRuleError(rule, err);
+            return;
+        }
+        for (const instance of instances) {
+            report.instancesChecked += 1;
+            const key = cursorKey(rule.primitive, instance);
+            let result = 'ok';
+            let detail;
+            try {
+                const verifyResult = await rule.verify(this.config.projectRoot, instance);
+                if (!verifyResult.ok) {
+                    report.gapsFound += verifyResult.mismatches.length;
+                    const hasConflict = verifyResult.mismatches.some((m) => m.reasonCode === 'user-edit-conflict');
+                    result = hasConflict ? 'conflict' : 'drift';
+                    detail = verifyResult.mismatches.map((m) => `${m.framework}: ${m.detail}`).join('; ');
+                    for (const m of verifyResult.mismatches) {
+                        this.emit('parity:gap-found', m);
+                    }
+                    if (result === 'drift' && this.shouldRemediate(rule)) {
+                        for (const m of verifyResult.mismatches) {
+                            if (m.framework === 'canonical')
+                                continue; // can't remediate canonical drift
+                            await this.attemptRemediate(rule, instance, m.framework, report);
+                        }
+                    }
+                    else if (result === 'conflict') {
+                        for (const m of verifyResult.mismatches) {
+                            this.emit('parity:remediation-refused', m);
+                            report.remediationRefused += 1;
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                result = 'error';
+                detail = err instanceof Error ? err.message : String(err);
+            }
+            const prior = this.state.cursors[key];
+            const unresolvedCount = result === 'ok'
+                ? 0
+                : (prior?.unresolvedCount ?? 0) + 1;
+            this.state.cursors[key] = {
+                lastScanAt: report.scannedAt,
+                lastResult: result,
+                lastDetail: detail,
+                unresolvedCount,
+            };
+            if (unresolvedCount >= 3 && result !== 'ok') {
+                DegradationReporter.getInstance().report({
+                    feature: `parity:${rule.primitive}:${instance}`,
+                    primary: 'Cross-framework parity for this instance',
+                    fallback: 'Drift persists across multiple scans',
+                    reason: detail ?? 'unknown',
+                    impact: `Drift unresolved for ${unresolvedCount} consecutive scans`,
+                });
+            }
+        }
+        // Orphan detection (per rule)
+        try {
+            const orphans = await rule.listOrphans(this.config.projectRoot);
+            for (const o of orphans) {
+                report.orphansFound += 1;
+                this.emit('parity:orphan-found', o);
+            }
+        }
+        catch (err) {
+            this.recordRuleError(rule, err);
+        }
+    }
+    async attemptRemediate(rule, instance, framework, report) {
+        if (framework === 'canonical')
+            return;
+        if (!this.config.enabledFrameworks.includes(framework))
+            return;
+        try {
+            await rule.remediate(this.config.projectRoot, instance, framework);
+            report.remediated += 1;
+            this.emit('parity:remediated', {
+                primitive: rule.primitive,
+                instance,
+                framework,
+            });
+        }
+        catch (err) {
+            report.remediationRefused += 1;
+            this.emit('parity:remediation-refused', {
+                primitive: rule.primitive,
+                instanceName: instance,
+                framework,
+                reasonCode: 'user-edit-conflict',
+                detail: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    shouldRemediate(rule) {
+        if (rule.remediationPolicy === 'flag-only')
+            return false;
+        if (this.config.remediationEnabled === false)
+            return false;
+        return true;
+    }
+    recordRuleError(rule, err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        console.error(`[FrameworkParitySentinel] rule ${rule.primitive} error: ${detail}`);
+        DegradationReporter.getInstance().report({
+            feature: `parity:${rule.primitive}`,
+            primary: 'Walk this primitive\'s parity rule',
+            fallback: 'Skip this rule for this scan; other rules unaffected',
+            reason: detail,
+            impact: `Drift detection for ${rule.primitive} primitive paused until next successful scan`,
+        });
+    }
+    // ── Persistence ────────────────────────────────────────────────
+    loadState() {
+        try {
+            if (fs.existsSync(this.statePath)) {
+                return JSON.parse(fs.readFileSync(this.statePath, 'utf-8'));
+            }
+        }
+        catch {
+            /* start fresh */
+        }
+        return { cursors: {}, lastScanAt: null };
+    }
+    saveState() {
+        try {
+            const dir = path.dirname(this.statePath);
+            fs.mkdirSync(dir, { recursive: true });
+            const tmpPath = `${this.statePath}.${process.pid}.tmp`;
+            fs.writeFileSync(tmpPath, JSON.stringify(this.state, null, 2));
+            fs.renameSync(tmpPath, this.statePath);
+        }
+        catch {
+            // @silent-fallback-ok — state loss just re-scans on next pass
+        }
+    }
+}
+// ── Test seam ─────────────────────────────────────────────────────
+/**
+ * Lookup a single rule by primitive. Re-exported here so the sentinel's
+ * tests and the HTTP routes have a single import surface.
+ * @internal
+ */
+export const _getParityRuleForTest = getParityRule;
+//# sourceMappingURL=FrameworkParitySentinel.js.map

package/dist/monitoring/FrameworkParitySentinel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrameworkParitySentinel.js","sourceRoot":"","sources":["../../src/monitoring/FrameworkParitySentinel.ts"],"names":[],"mappings":"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"}

package/dist/providers/parity/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/providers/parity/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AASlE,wBAAgB,aAAa,CAAC,SAAS,EAAE,mBAAmB,GAAG,UAAU,GAAG,SAAS,CAEpF;AAED,wBAAgB,eAAe,IAAI,aAAa,CAAC,UAAU,CAAC,CAE3D;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,mBAAmB,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,IAAI,CAOtG"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/providers/parity/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAWlE,wBAAgB,aAAa,CAAC,SAAS,EAAE,mBAAmB,GAAG,UAAU,GAAG,SAAS,CAEpF;AAED,wBAAgB,eAAe,IAAI,aAAa,CAAC,UAAU,CAAC,CAE3D;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,mBAAmB,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,IAAI,CAOtG"}

package/dist/providers/parity/registry.js

@@ -13,9 +13,11 @@
  */
 import { skillParityRule } from './rules/skillParityRule.js';
 import { hookParityRule } from './rules/hookParityRule.js';
+import { memoryParityRule } from './rules/memoryParityRule.js';
 const RULES = new Map([
     [skillParityRule.primitive, skillParityRule],
     [hookParityRule.primitive, hookParityRule],
+    [memoryParityRule.primitive, memoryParityRule],
 ]);
 export function getParityRule(primitive) {
     return RULES.get(primitive);

package/dist/providers/parity/registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/providers/parity/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,MAAM,KAAK,GAAyC,IAAI,GAAG,CAAC;IAC1D,CAAC,eAAe,CAAC,SAAS,EAAE,eAAe,CAAC;IAC5C,CAAC,cAAc,CAAC,SAAS,EAAE,cAAc,CAAC;CAC3C,CAAC,CAAC;AAEH,MAAM,UAAU,aAAa,CAAC,SAA8B;IAC1D,OAAO,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AAC9B,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;AAC7B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CAAC,SAA8B,EAAE,IAAgB;IACxF,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACnC,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC3B,OAAO,GAAG,EAAE;QACV,IAAI,KAAK;YAAE,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;;YAClC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAC/B,CAAC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/providers/parity/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,MAAM,KAAK,GAAyC,IAAI,GAAG,CAAC;IAC1D,CAAC,eAAe,CAAC,SAAS,EAAE,eAAe,CAAC;IAC5C,CAAC,cAAc,CAAC,SAAS,EAAE,cAAc,CAAC;IAC1C,CAAC,gBAAgB,CAAC,SAAS,EAAE,gBAAgB,CAAC;CAC/C,CAAC,CAAC;AAEH,MAAM,UAAU,aAAa,CAAC,SAA8B;IAC1D,OAAO,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AAC9B,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;AAC7B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CAAC,SAA8B,EAAE,IAAgB;IACxF,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACnC,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC3B,OAAO,GAAG,EAAE;QACV,IAAI,KAAK;YAAE,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;;YAClC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAC/B,CAAC,CAAC;AACJ,CAAC"}

package/dist/providers/parity/rules/memoryParityRule.d.ts

@@ -0,0 +1,31 @@
+/**
+ * memoryParityRule — parity rule for the Memory functional primitive.
+ *
+ * Specs:
+ *   - specs/instar-concepts/memory.md (canonical shape)
+ *   - specs/frameworks/claude-code/memory.md
+ *   - specs/frameworks/codex-cli/memory.md
+ *
+ * Memory is substrate-bound: the canonical artifacts (`.instar/AGENT.md`,
+ * `.instar/USER.md`, `.instar/MEMORY.md`, `.instar/state/topic-memory.sqlite`)
+ * are framework-agnostic files on disk. This rule's verify() confirms each
+ * required artifact is present, non-empty, and (for markdown) parses cleanly.
+ *
+ * v0.1 deliberately does NOT auto-remediate. Memory contains agent identity
+ * and accumulated learnings — silent regeneration would erase intentional
+ * drift. remediate() throws with a structured detail pointing to the documented
+ * repair procedure.
+ *
+ * Loading canonical Memory into framework system-prompts (CLAUDE.md / AGENTS.md
+ * references) is the InstructionFile primitive's responsibility — separate.
+ */
+import type { ParityRule } from '../types.js';
+/**
+ * The Memory primitive has a fixed canonical artifact set, not user-named
+ * instances like Skill/Hook. listInstances() returns the artifact paths so the
+ * sentinel can iterate verify() over each, but verify() is also defined to
+ * accept any artifact path and return ok:true if it's not in the known set
+ * (defensive: sentinel might call with stale names after a config change).
+ */
+export declare const memoryParityRule: ParityRule;
+//# sourceMappingURL=memoryParityRule.d.ts.map

package/dist/providers/parity/rules/memoryParityRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryParityRule.d.ts","sourceRoot":"","sources":["../../../../src/providers/parity/rules/memoryParityRule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAMH,OAAO,KAAK,EACV,UAAU,EAGX,MAAM,aAAa,CAAC;AAiLrB;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,UAmD9B,CAAC"}

package/dist/providers/parity/rules/memoryParityRule.js

@@ -0,0 +1,198 @@
+/**
+ * memoryParityRule — parity rule for the Memory functional primitive.
+ *
+ * Specs:
+ *   - specs/instar-concepts/memory.md (canonical shape)
+ *   - specs/frameworks/claude-code/memory.md
+ *   - specs/frameworks/codex-cli/memory.md
+ *
+ * Memory is substrate-bound: the canonical artifacts (`.instar/AGENT.md`,
+ * `.instar/USER.md`, `.instar/MEMORY.md`, `.instar/state/topic-memory.sqlite`)
+ * are framework-agnostic files on disk. This rule's verify() confirms each
+ * required artifact is present, non-empty, and (for markdown) parses cleanly.
+ *
+ * v0.1 deliberately does NOT auto-remediate. Memory contains agent identity
+ * and accumulated learnings — silent regeneration would erase intentional
+ * drift. remediate() throws with a structured detail pointing to the documented
+ * repair procedure.
+ *
+ * Loading canonical Memory into framework system-prompts (CLAUDE.md / AGENTS.md
+ * references) is the InstructionFile primitive's responsibility — separate.
+ */
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import yaml from 'js-yaml';
+const ARTIFACTS = [
+    {
+        relPath: '.instar/AGENT.md',
+        kind: 'markdown',
+        required: true,
+        label: 'agent identity',
+    },
+    {
+        relPath: '.instar/USER.md',
+        kind: 'markdown',
+        required: true,
+        label: 'user profile',
+    },
+    {
+        relPath: '.instar/MEMORY.md',
+        kind: 'markdown',
+        required: true,
+        label: 'persistent learnings',
+    },
+    {
+        relPath: '.instar/state/topic-memory.sqlite',
+        kind: 'sqlite',
+        required: false,
+        label: 'topic memory store',
+    },
+];
+const SQLITE_MAGIC = 'SQLite format 3\0';
+class CanonicalMemoryError extends Error {
+    artifact;
+    reasonCode;
+    constructor(artifact, reasonCode, message) {
+        super(message);
+        this.name = 'CanonicalMemoryError';
+        this.artifact = artifact;
+        this.reasonCode = reasonCode;
+    }
+}
+async function pathExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function verifyMarkdownArtifact(absPath, artifact) {
+    let raw;
+    try {
+        raw = await fs.readFile(absPath, 'utf-8');
+    }
+    catch (err) {
+        throw new CanonicalMemoryError(artifact.relPath, 'canonical-read-error', `cannot read ${artifact.label} at ${artifact.relPath}: ${err.message}`);
+    }
+    if (raw.trim().length === 0) {
+        throw new CanonicalMemoryError(artifact.relPath, 'canonical-read-error', `${artifact.label} at ${artifact.relPath} is empty — repair required`);
+    }
+    // Optional frontmatter — if it starts with `---`, parse it. If it doesn't,
+    // that's fine (USER.md / MEMORY.md often have no frontmatter).
+    if (raw.startsWith('---\n')) {
+        const close = raw.indexOf('\n---', 4);
+        if (close < 0) {
+            throw new CanonicalMemoryError(artifact.relPath, 'canonical-read-error', `${artifact.label} at ${artifact.relPath} has unterminated frontmatter`);
+        }
+        const fm = raw.slice(4, close);
+        try {
+            yaml.load(fm, { schema: yaml.FAILSAFE_SCHEMA, json: false });
+        }
+        catch (err) {
+            throw new CanonicalMemoryError(artifact.relPath, 'canonical-read-error', `${artifact.label} at ${artifact.relPath}: YAML frontmatter parse error: ${err.message}`);
+        }
+    }
+}
+async function verifySqliteArtifact(absPath, artifact) {
+    let fh;
+    try {
+        fh = await fs.open(absPath, 'r');
+    }
+    catch (err) {
+        throw new CanonicalMemoryError(artifact.relPath, 'canonical-read-error', `cannot open ${artifact.label} at ${artifact.relPath}: ${err.message}`);
+    }
+    try {
+        const buf = Buffer.alloc(SQLITE_MAGIC.length);
+        const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
+        if (bytesRead < buf.length || buf.toString('binary') !== SQLITE_MAGIC) {
+            throw new CanonicalMemoryError(artifact.relPath, 'canonical-read-error', `${artifact.label} at ${artifact.relPath} is not a valid SQLite file (magic bytes mismatch)`);
+        }
+    }
+    finally {
+        await fh.close();
+    }
+}
+async function verifyArtifact(projectRoot, artifact) {
+    const abs = path.join(projectRoot, artifact.relPath);
+    const exists = await pathExists(abs);
+    if (!exists) {
+        if (!artifact.required)
+            return null;
+        return {
+            primitive: 'memory',
+            instanceName: artifact.relPath,
+            framework: 'canonical',
+            reasonCode: 'canonical-read-error',
+            detail: `${artifact.label} at ${artifact.relPath} is missing — required artifact for the Memory primitive`,
+        };
+    }
+    try {
+        if (artifact.kind === 'markdown') {
+            await verifyMarkdownArtifact(abs, artifact);
+        }
+        else {
+            await verifySqliteArtifact(abs, artifact);
+        }
+    }
+    catch (err) {
+        if (err instanceof CanonicalMemoryError) {
+            return {
+                primitive: 'memory',
+                instanceName: artifact.relPath,
+                framework: 'canonical',
+                reasonCode: err.reasonCode,
+                detail: err.message,
+            };
+        }
+        throw err;
+    }
+    return null;
+}
+/**
+ * The Memory primitive has a fixed canonical artifact set, not user-named
+ * instances like Skill/Hook. listInstances() returns the artifact paths so the
+ * sentinel can iterate verify() over each, but verify() is also defined to
+ * accept any artifact path and return ok:true if it's not in the known set
+ * (defensive: sentinel might call with stale names after a config change).
+ */
+export const memoryParityRule = {
+    primitive: 'memory',
+    // Memory is framework-agnostic — the verifier ignores framework, but we
+    // declare both so the sentinel includes Memory in every framework's matrix
+    // cell and surfaces drift consistently.
+    frameworks: ['claude-code', 'codex-cli'],
+    remediationPolicy: 'flag-only',
+    async verify(projectRoot, instanceName) {
+        const artifact = ARTIFACTS.find((a) => a.relPath === instanceName);
+        if (!artifact) {
+            return { ok: true, mismatches: [] };
+        }
+        const mismatch = await verifyArtifact(projectRoot, artifact);
+        return mismatch
+            ? { ok: false, mismatches: [mismatch] }
+            : { ok: true, mismatches: [] };
+    },
+    async listInstances(_projectRoot) {
+        return ARTIFACTS.map((a) => a.relPath);
+    },
+    async remediate(_projectRoot, instanceName, _framework) {
+        const artifact = ARTIFACTS.find((a) => a.relPath === instanceName);
+        const label = artifact?.label ?? instanceName;
+        throw new Error(`memory primitive: refused to remediate ${instanceName} (${label}) — ` +
+            `Memory artifacts are user/agent-authored and never auto-regenerated. ` +
+            `Repair procedure: AGENT.md/USER.md → re-init via \`instar init\`; ` +
+            `MEMORY.md → restore from git history or backup; ` +
+            `topic-memory.sqlite → restore from backup. ` +
+            `See specs/instar-concepts/memory.md for full procedure.`);
+    },
+    async listOrphans(_projectRoot) {
+        // No rendering callsites in v0.1; no orphans possible.
+        return [];
+    },
+    async removeOrphans(_projectRoot, _framework) {
+        return [];
+    },
+};
+//# sourceMappingURL=memoryParityRule.js.map

package/dist/providers/parity/rules/memoryParityRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryParityRule.js","sourceRoot":"","sources":["../../../../src/providers/parity/rules/memoryParityRule.ts"],"names":[],"mappings":"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"}

package/dist/providers/parity/toolNameMapping.d.ts

@@ -0,0 +1,43 @@
+/**
+ * toolNameMapping — canonical tool-name vocabulary + per-framework mapping.
+ *
+ * Specs:
+ *   - specs/instar-concepts/tool.md
+ *   - specs/frameworks/claude-code/tools.md
+ *   - specs/frameworks/codex-cli/tools.md
+ *
+ * Consumed by other Layer-3 primitives' renderers when they need to map
+ * a canonical `allowed-tools` list to framework-native tool names.
+ *
+ * v0.1: ships the table + lookup helpers. The Skill primitive's `allowed-tools`
+ * rendering (the C3 deferral from Skill convergence) wires in next.
+ */
+import type { IntelligenceFramework } from '../../core/intelligenceProviderFactory.js';
+export interface ToolNameEntry {
+    canonical: string;
+    claude: string;
+    codex: string;
+}
+export declare const TOOL_NAME_MAPPING: ReadonlyArray<ToolNameEntry>;
+/**
+ * Translate one canonical tool name into its framework-native form.
+ *
+ * Returns null if the canonical name is unknown. Callers should treat null
+ * as a hard error (don't silently drop tool restrictions — that widens the
+ * permission surface).
+ */
+export declare function renderCanonicalToolName(canonical: string, framework: IntelligenceFramework): string | null;
+/**
+ * Translate an array of canonical tool names. Returns a parallel array where
+ * each element is either the framework-native name or null (for unknown).
+ * Useful in renderers that want to surface unknowns to the operator.
+ */
+export declare function renderCanonicalToolList(canonicals: ReadonlyArray<string>, framework: IntelligenceFramework): Array<{
+    canonical: string;
+    native: string | null;
+}>;
+/**
+ * List all known canonical tool names (for documentation + validation).
+ */
+export declare function listCanonicalToolNames(): ReadonlyArray<string>;
+//# sourceMappingURL=toolNameMapping.d.ts.map

package/dist/providers/parity/toolNameMapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolNameMapping.d.ts","sourceRoot":"","sources":["../../../src/providers/parity/toolNameMapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAC;AAEvF,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,aAAa,CAa1D,CAAC;AAQF;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,qBAAqB,GAC/B,MAAM,GAAG,IAAI,CAWf;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,EACjC,SAAS,EAAE,qBAAqB,GAC/B,KAAK,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAErD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,aAAa,CAAC,MAAM,CAAC,CAE9D"}

package/dist/providers/parity/toolNameMapping.js

@@ -0,0 +1,65 @@
+/**
+ * toolNameMapping — canonical tool-name vocabulary + per-framework mapping.
+ *
+ * Specs:
+ *   - specs/instar-concepts/tool.md
+ *   - specs/frameworks/claude-code/tools.md
+ *   - specs/frameworks/codex-cli/tools.md
+ *
+ * Consumed by other Layer-3 primitives' renderers when they need to map
+ * a canonical `allowed-tools` list to framework-native tool names.
+ *
+ * v0.1: ships the table + lookup helpers. The Skill primitive's `allowed-tools`
+ * rendering (the C3 deferral from Skill convergence) wires in next.
+ */
+export const TOOL_NAME_MAPPING = [
+    { canonical: 'read', claude: 'Read', codex: 'view' },
+    { canonical: 'edit', claude: 'Edit', codex: 'apply_patch' },
+    { canonical: 'write', claude: 'Write', codex: 'apply_patch' },
+    { canonical: 'multi-edit', claude: 'MultiEdit', codex: 'apply_patch' },
+    { canonical: 'bash', claude: 'Bash', codex: 'shell' },
+    { canonical: 'grep', claude: 'Grep', codex: 'grep' },
+    { canonical: 'glob', claude: 'Glob', codex: 'glob' },
+    { canonical: 'web-fetch', claude: 'WebFetch', codex: 'read_url' },
+    { canonical: 'web-search', claude: 'WebSearch', codex: 'web_search' },
+    { canonical: 'task', claude: 'Task', codex: 'multi_agent' },
+    { canonical: 'todo-write', claude: 'TodoWrite', codex: 'todo_write' },
+    { canonical: 'notebook-edit', claude: 'NotebookEdit', codex: 'notebook_edit' },
+];
+const CANONICAL_INDEX = new Map(TOOL_NAME_MAPPING.map((e) => [e.canonical, e]));
+const MCP_CANONICAL_RE = /^mcp:([a-z0-9][a-z0-9-]*):([a-z0-9][a-z0-9_-]*)$/i;
+/**
+ * Translate one canonical tool name into its framework-native form.
+ *
+ * Returns null if the canonical name is unknown. Callers should treat null
+ * as a hard error (don't silently drop tool restrictions — that widens the
+ * permission surface).
+ */
+export function renderCanonicalToolName(canonical, framework) {
+    const mcp = canonical.match(MCP_CANONICAL_RE);
+    if (mcp) {
+        const [, server, tool] = mcp;
+        return framework === 'claude-code'
+            ? `mcp__${server}__${tool}`
+            : `mcp.${server}.${tool}`;
+    }
+    const entry = CANONICAL_INDEX.get(canonical);
+    if (!entry)
+        return null;
+    return framework === 'claude-code' ? entry.claude : entry.codex;
+}
+/**
+ * Translate an array of canonical tool names. Returns a parallel array where
+ * each element is either the framework-native name or null (for unknown).
+ * Useful in renderers that want to surface unknowns to the operator.
+ */
+export function renderCanonicalToolList(canonicals, framework) {
+    return canonicals.map((c) => ({ canonical: c, native: renderCanonicalToolName(c, framework) }));
+}
+/**
+ * List all known canonical tool names (for documentation + validation).
+ */
+export function listCanonicalToolNames() {
+    return TOOL_NAME_MAPPING.map((e) => e.canonical);
+}
+//# sourceMappingURL=toolNameMapping.js.map

package/dist/providers/parity/toolNameMapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolNameMapping.js","sourceRoot":"","sources":["../../../src/providers/parity/toolNameMapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH,MAAM,CAAC,MAAM,iBAAiB,GAAiC;IAC7D,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;IACpD,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE;IAC3D,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE;IAC7D,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,EAAE;IACtE,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE;IACrD,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;IACpD,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;IACpD,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE;IACjE,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,EAAE;IACrE,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE;IAC3D,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,EAAE;IACrE,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,EAAE;CAC/E,CAAC;AAEF,MAAM,eAAe,GAAG,IAAI,GAAG,CAC7B,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAC/C,CAAC;AAEF,MAAM,gBAAgB,GAAG,mDAAmD,CAAC;AAE7E;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CACrC,SAAiB,EACjB,SAAgC;IAEhC,MAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;IAC9C,IAAI,GAAG,EAAE,CAAC;QACR,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,GAAG,CAAC;QAC7B,OAAO,SAAS,KAAK,aAAa;YAChC,CAAC,CAAC,QAAQ,MAAM,KAAK,IAAI,EAAE;YAC3B,CAAC,CAAC,OAAO,MAAM,IAAI,IAAI,EAAE,CAAC;IAC9B,CAAC;IACD,MAAM,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAC7C,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,OAAO,SAAS,KAAK,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC;AAClE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CACrC,UAAiC,EACjC,SAAgC;IAEhC,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,uBAAuB,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC;AAClG,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,sBAAsB;IACpC,OAAO,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;AACnD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instar",
-  "version": "0.28.117",
+  "version": "0.28.119",
   "description": "Persistent autonomy infrastructure for AI agents",
   "type": "module",
   "main": "dist/index.js",

package/src/data/builtin-manifest.json

@@ -1,8 +1,8 @@
 {
   "$schema": "./builtin-manifest.schema.json",
   "schemaVersion": 1,
-  "generatedAt": "2026-05-19T01:38:36.605Z",
-  "instarVersion": "0.28.117",
+  "generatedAt": "2026-05-19T02:38:16.455Z",
+  "instarVersion": "0.28.119",
   "entryCount": 189,
   "entries": {
     "hook:session-start": {

package/upgrades/0.28.118.md

@@ -0,0 +1,35 @@
+# Upgrade Guide — v1.0.4
+
+<!-- bump: patch -->
+
+## What Changed
+
+Lands the remaining three Layer-3 functional primitives from the framework-functional-parity rollout: **Agent**, **Tool**, and **Memory**. Batched into a single PR because each ships a relatively small surface (concept spec + framework specs + small code artifact) and they share the same conceptual frame (canonical-source-of-truth + per-framework rendering).
+
+**Agent primitive (v0.1):** concept spec + ELI16 + per-framework specs. No parity rule yet — pending Codex subagent surface research. The current Claude implementation pattern (.claude/agents/<name>.md) is documented but not yet wired to a canonical source. Tracked as a v0.2 follow-up; ships now to lock the cross-framework contract.
+
+**Tool primitive (v0.1):** concept spec + ELI16 + per-framework specs + TOOL_NAME_MAPPING table as code (src/providers/parity/toolNameMapping.ts). Provides the canonical tool-name vocabulary (read, bash, web-fetch, mcp:server:tool) and helpers (renderCanonicalToolName, renderCanonicalToolList) that other primitives' renderers will consume when wiring allowed-tools fields. The C3 deferral from Skill convergence (Claude allowed-tools frontmatter + Codex dependencies.tools rendering) unblocks here — but the wiring itself happens when Skill v0.2 lands.
+
+**Memory primitive (v0.1):** concept spec + ELI16 + per-framework specs + memoryParityRule (verifier-only). Confirms canonical Memory artifacts (.instar/AGENT.md, .instar/USER.md, .instar/MEMORY.md, .instar/state/topic-memory.sqlite) are present, non-empty, and well-formed. Deliberately does NOT auto-remediate — Memory contains agent identity and accumulated learnings, so silent regeneration would erase intentional drift. Corruption is loudly surfaced, repair is human-authorized. Loading canonical Memory into framework system-prompts (CLAUDE.md / AGENTS.md references) is the InstructionFile primitive's responsibility (next, separate spec).
+
+Registry now exposes three rules: skill, hook, memory. Agent + Tool deliberately have no registry entry yet (Agent: rule pending; Tool: substrate-bound, ships as code-importable mapping rather than as a per-instance rule).
+
+## What to Tell Your User
+
+- "Three more functional primitives now have their canonical contracts in place: Agent (the spec is locked; the parity rule comes after Codex subagent research), Tool (a canonical vocabulary of names like read, bash, web-fetch that maps to each framework's native naming), and Memory (a verifier that confirms your AGENT.md, USER.md, and MEMORY.md files in the instar folder are present and well-formed)."
+- "Memory verification is deliberately non-destructive — if it detects corruption, you'll get a clear repair pointer instead of an auto-overwrite that could wipe your identity drift."
+
+## Summary of New Capabilities
+
+| Capability | How to Use |
+|-----------|-----------|
+| Canonical tool-name vocabulary | Import renderCanonicalToolName or renderCanonicalToolList from src/providers/parity/toolNameMapping.js to translate canonical names into framework-native form. |
+| Memory parity rule (programmatic) | Available via the parity registry — getParityRule('memory'). Verifier-only in v0.1; no auto-fix. |
+| Agent + Tool + Memory concept specs | Read specs/instar-concepts/{agent,tool,memory}.md (+ .eli16.md companions) for the cross-framework contracts. |
+
+## Deferred (Tracked Follow-ups)
+
+- Agent parity rule (pending Codex subagent surface research).
+- Tool: wire TOOL_NAME_MAPPING into Skill v0.2's allowed-tools rendering (resolves the C3 deferral from Skill convergence).
+- Memory: schema validation beyond YAML-parse + body-non-empty (e.g. AGENT.md required identity sections).
+- InstructionFile primitive — the loading-vehicle for canonical Memory into framework system-prompts. Separate spec, next.

package/upgrades/0.28.119.md

@@ -0,0 +1,37 @@
+# Upgrade Guide — v1.0.5
+
+<!-- bump: patch -->
+
+## What Changed
+
+Lands the FrameworkParitySentinel — the class that walks the Layer-3 parity rules registry (Skill / Hook / Memory), runs each rule's verify() per instance, and routes drift to events (or to remediation, per the rule's declared policy).
+
+v0.1 ships the sentinel as a building block — class + 12 unit tests. HTTP routes (GET /api/framework-parity/status, POST /api/framework-parity/scan) and server.ts boot integration are deferred to a focused follow-up PR. This matches the precedent set by Skill / Hook / Memory parity rules: each shipped as a registry building block first, with operational wiring as a separate step.
+
+Key safety locks: per-rule remediationPolicy is the authority (flag-only never auto-remediates; mirror-trust does); the sentinel-level remediationEnabled config can DOWNGRADE mirror-trust to flag-only but never UPGRADE flag-only. Memory's sacrosanct status is preserved unconditionally. Concurrent scan calls short-circuit to prevent pileup. User-edit-conflict refuses remediation and emits a structured event.
+
+Five new events: parity:gap-found, parity:remediated, parity:remediation-refused, parity:orphan-found, parity:scan-complete. Persistent state at .instar/state/framework-parity-sentinel.json with per (primitive × instance) cursors.
+
+Spec at specs/instar-foundations/framework-parity-sentinel.md (converged + approved). ELI16 companion + convergence report alongside. Original 2026-05-18 proposal at specs/provider-portability/13-framework-parity-sentinel.md is now superseded — left in place for historical reference, frontmatter unchanged.
+
+## What to Tell Your User
+
+- "The piece that runs the cross-framework drift checks is now built. It walks the parity rules every 30 minutes (when wired into the server, coming next), spots when your canonical files have drifted from their rendered forms on Claude or Codex, and either re-renders or flags the drift for you — based on the rule's safety policy."
+- "Memory stays sacrosanct: the sentinel will never auto-regenerate your AGENT.md, USER.md, or MEMORY.md. If they're corrupted, you get a structured alert pointing at the repair procedure."
+
+## Summary of New Capabilities
+
+| Capability | How to Use |
+|-----------|-----------|
+| FrameworkParitySentinel class | Import from src/monitoring/FrameworkParitySentinel.js. Construct with projectRoot + stateDir + enabledFrameworks. Call scan() for one pass or start() for interval mode. |
+| Per-instance scan cursors | sentinel.getStatus() returns the per (primitive × instance) cursor state — used by the upcoming HTTP route. |
+| Five EventEmitter events | parity:gap-found, parity:remediated, parity:remediation-refused, parity:orphan-found, parity:scan-complete. |
+
+## Deferred (Tracked Follow-ups)
+
+- HTTP routes (GET /api/framework-parity/status, POST /api/framework-parity/scan).
+- server.ts boot integration (construction + start + RouteContext wiring).
+- Integration + E2E tests (land with the HTTP wiring).
+- chokidar source-change watcher (v0.2).
+- Per-instance POST /api/framework-parity/remediate route (v0.2 — pending trust integration).
+- Conversational-action layer wiring (Step 6 of the rollout).

package/upgrades/side-effects/feat-framework-parity-sentinel.md

@@ -0,0 +1,94 @@
+# Side-Effects Review — FrameworkParitySentinel v0.1 (building block)
+
+**Version / slug:** `feat-framework-parity-sentinel`
+**Date:** 2026-05-19
+**Author:** Echo (autonomous mode, hybrid C)
+
+## Summary of the change
+
+Lands the FrameworkParitySentinel as a **building block** — the class that walks the Layer-3 parity rules registry, calls each rule's `verify()` per instance, surfaces drift via events, and (per rule's `remediationPolicy`) optionally calls `remediate()`. Ships with unit tests and structured spec docs.
+
+**Deliberately scoped narrow:** HTTP routes (`GET /api/framework-parity/status`, `POST /api/framework-parity/scan`) and server.ts boot integration are deferred to a follow-up PR. This matches the precedent set by Skill/Hook/Memory parity rules in PRs #252/#253/#254 — each shipped as a building block via the parity registry, with boot integration as a separate step. Shipping the sentinel class now unblocks the registry consumer side; the follow-up wires it into the server lifecycle.
+
+**Files changed (specs):**
+- specs/instar-foundations/framework-parity-sentinel.md (new, converged + approved per pre-auth)
+- specs/instar-foundations/framework-parity-sentinel.eli16.md (new)
+- docs/specs/reports/framework-parity-sentinel-convergence.md (new)
+
+**Files changed (source):**
+- src/monitoring/FrameworkParitySentinel.ts (new — class + lifecycle + scan + state I/O + EventEmitter)
+
+**Files changed (tests):**
+- tests/unit/monitoring/FrameworkParitySentinel.test.ts (new — 12 tests)
+
+**Files changed (release notes):**
+- upgrades/NEXT.md (new)
+- package.json (version bump)
+
+## Decision-point inventory
+
+- **Building-block scope**: ships the class + unit tests; HTTP routes + boot wiring as a follow-up. Matches PR #252/#253/#254 precedent.
+- **Scan cadence default**: 30 min (1_800_000 ms). Configurable.
+- **Initial scan delay**: 60s (allows server to settle before first pass).
+- **Concurrent-scan short-circuit**: second concurrent `scan()` call returns an empty report; prevents pileup on slow rules.
+- **Remediation gating**: per-rule `remediationPolicy` is the authority. Sentinel-level `remediationEnabled` config can DOWNGRADE mirror-trust to flag-only but never UPGRADE flag-only to mirror-trust.
+- **State schema**: `cursors[primitive::instance]` with `lastScanAt`, `lastResult`, `lastDetail`, `unresolvedCount`. Atomic writes via tempfile+rename.
+- **Degradation threshold**: 3 consecutive scans with unresolved drift trips a `DegradationReporter.report()`.
+- **Canonical-side mismatches are signal-only**: when `verify()` returns `framework: 'canonical'` (e.g. missing AGENT.md), the sentinel emits `parity:gap-found` but does NOT call `remediate()` — only the rule can mutate canonical, and Memory's rule throws by design.
+- **Event vocabulary**: `parity:gap-found`, `parity:remediated`, `parity:remediation-refused`, `parity:orphan-found`, `parity:scan-complete`.
+- **Orphan removal is opt-in**: `listOrphans()` always runs; `removeOrphans()` requires explicit operator action (no auto-fire in v0.1).
+
+## Over-block / under-block analysis
+
+**Over-block risk:** the sentinel never blocks operations — it scans + emits + (optionally) re-renders. Worst case is a noisy event stream, filterable at the EventEmitter consumer.
+
+**Under-block risk:** if a rule's `verify()` throws, the sentinel marks that rule failed (via DegradationReporter) and continues with other rules. The failed rule's instances stay at their prior cursor state — drift may persist longer than 30 min until the rule's verify recovers. Mitigated by Degradation reporting (3-consecutive-failure trip) so operators are notified.
+
+**Under-block risk (concurrent scan):** the short-circuit returns an empty report. If a user POSTs `/scan` while an interval scan is in flight (when routes ship), they get back empty + the interval scan continues. Acceptable for v0.1 — adding queue/wait complicates state.
+
+## Level-of-abstraction fit
+
+- Sentinel is the orchestrator. It owns scan timing, state, event emission. Routes/wiring are NOT in v0.1.
+- Rules own canonical definitions, rendering, verification, remediation.
+- Boundary is clean — sentinel never reads canonical formats directly, never knows what a "skill" or "hook" is. Just the registry interface.
+
+## Signal-vs-authority compliance
+
+- Sentinel emits signals (`parity:gap-found`). Rules' `remediationPolicy` and sentinel's `remediationEnabled` are the layered authority.
+- Sentinel never overrides a rule's `flag-only` policy (cannot upgrade).
+- Sentinel respects `user-edit-conflict` by short-circuiting remediation and emitting `parity:remediation-refused`.
+
+## Interaction surface
+
+- Adds one new class under `src/monitoring/`. No HTTP routes, no server.ts wiring, no config additions in v0.1.
+- Optional state file at `.instar/state/framework-parity-sentinel.json` — only written when `scan()` is called. Cold-start safe.
+- No changes to existing rules, registries, or per-primitive infrastructure.
+- No migrations needed (cold-start is a no-op until the follow-up wires it in).
+
+## Rollback cost
+
+- Pure-add. Revert removes the sentinel + tests + spec + state file. No data migrations.
+- Worst-case bug: spurious remediation on healthy artifacts when the follow-up wires it. Mitigated by user-edit-conflict short-circuit + per-rule policy + future `remediationEnabled` kill-switch.
+- Operator emergency (post-follow-up): set `frameworkParity.remediationEnabled: false` in `.instar/config.json` and restart — sentinel becomes signal-only.
+
+## Test coverage
+
+- Unit: 12 tests covering rule walking, event emission for all 5 events, remediation policy routing (mirror-trust + flag-only + user-edit-conflict + config override), concurrent-scan short-circuit, state persistence round-trip, start/stop lifecycle idempotency.
+- Integration + E2E: deferred to the follow-up PR that wires HTTP routes — matches PR #252/#253/#254 precedent (the parity rules in those PRs also shipped unit-tests-only as building blocks).
+
+## Documentation
+
+- Concept spec + ELI16 at `specs/instar-foundations/`.
+- Convergence report at `docs/specs/reports/`.
+- NEXT.md with "What to Tell Your User" entries.
+
+## Deferred (tracked, not silent)
+
+- **HTTP routes** (`GET /api/framework-parity/status`, `POST /api/framework-parity/scan`) — follow-up PR.
+- **server.ts boot integration** (construction + start + RouteContext wiring) — follow-up PR.
+- **Integration + E2E tests** — land with the HTTP wiring.
+- **chokidar source-change watcher** — v0.2.
+- **POST /api/framework-parity/remediate per-instance route** — v0.2 (pending trust integration).
+- **Trust-level integration** for mirror-trust gating (v0.2 — hardcodes allow for v0.1).
+- **Backfill migration** of existing-agent installed base (separate one-shot tool).
+- **Conversational-action layer** (Step 6 of the rollout).

package/upgrades/side-effects/feat-primitives-batch.md

@@ -0,0 +1,105 @@
+# Side-Effects Review — Agent + Tool + Memory primitives (batched)
+
+**Version / slug:** `feat-primitives-batch`
+**Date:** 2026-05-19
+**Author:** Echo (autonomous mode, hybrid C)
+
+## Summary of the change
+
+Lands the remaining three Layer-3 functional primitive specs from the framework-functional-parity rollout as one batched PR: **Agent**, **Tool**, **Memory**. Each ships a small surface (concept spec + framework specs + small code artifact where applicable) and they share the same conceptual frame, so batching avoids three near-identical PR review cycles.
+
+**Files changed (specs):**
+- specs/instar-concepts/agent.md (new, converged + approved per pre-auth)
+- specs/instar-concepts/agent.eli16.md (new)
+- specs/instar-concepts/tool.md (new, converged + approved per pre-auth)
+- specs/instar-concepts/tool.eli16.md (new)
+- specs/instar-concepts/memory.md (new, converged + approved per pre-auth)
+- specs/instar-concepts/memory.eli16.md (new)
+- specs/frameworks/claude-code/agents.md (new)
+- specs/frameworks/claude-code/tools.md (new)
+- specs/frameworks/claude-code/memory.md (new)
+- specs/frameworks/codex-cli/agents.md (new)
+- specs/frameworks/codex-cli/tools.md (new)
+- specs/frameworks/codex-cli/memory.md (new)
+- docs/specs/reports/agent-concept-convergence.md (new)
+- docs/specs/reports/tool-concept-convergence.md (new)
+- docs/specs/reports/memory-concept-convergence.md (new)
+
+**Files changed (source):**
+- src/providers/parity/toolNameMapping.ts (new — TOOL_NAME_MAPPING table + renderers)
+- src/providers/parity/rules/memoryParityRule.ts (new — verifier-only)
+- src/providers/parity/registry.ts (memoryParityRule registered)
+
+**Files changed (tests):**
+- tests/unit/providers/parity/toolNameMapping.test.ts (new — 21 tests)
+- tests/unit/providers/parity/memoryParityRule.test.ts (new — 18 tests)
+- tests/unit/providers/parity/registry.test.ts (updated for 3-rule registry)
+
+**Files changed (release notes):**
+- upgrades/NEXT.md (rewritten for v1.0.4)
+- package.json (version bump 1.0.3 → 1.0.4)
+
+## Decision-point inventory
+
+- **Batching three primitives in one PR**: justified by shared frame + small surfaces; each gets its own concept spec + ELI16 + framework specs + convergence report, so review traceability per primitive is preserved.
+- **Agent primitive ships without a parity rule**: deliberate — Codex subagent surface (whether/how subagent spawning is exposed) needs live research. Spec ships now to lock the cross-framework contract; rule lands when research completes. Tracked in spec's "v0.1 deferred items" section.
+- **Tool primitive ships TOOL_NAME_MAPPING as code, not as a per-instance rule**: Tools are framework-provided, not user-authored. The "instance" of a Tool isn't something to render; the cross-framework concern is the vocabulary, which lives in a shared mapping table. No registry entry — other primitives' renderers import the helpers directly.
+- **Memory primitive uses flag-only remediation policy**: Memory contains agent identity + learnings. Silent regeneration would erase intentional drift. remediate() throws with a documented repair procedure; corruption surfaces loudly via verify().
+- **SQLite verification depth**: v0.1 checks magic bytes only (cheap, fail-loud). Full schema validation deferred — the topic-memory.sqlite schema is owned by its own substrate primitive.
+- **Memory artifact set is fixed at four**: AGENT.md, USER.md, MEMORY.md (required); topic-memory.sqlite (optional). Other `.instar/` files (config.json, jobs.json, state/*) are NOT Memory — they belong to other primitives (Config, Job, State).
+- **MCP canonical syntax `mcp:server:tool`**: matches the spec convention. Renders to `mcp__server__tool` (Claude) / `mcp.server.tool` (Codex).
+
+## Over-block / under-block analysis
+
+**Over-block risk (Tool):** if a canonical tool name isn't in TOOL_NAME_MAPPING, `renderCanonicalToolName` returns null. Callers are documented to treat this as a hard error (don't silently drop, that widens the permission surface). v0.1 has no callers yet; risk surfaces when Skill v0.2 wires `allowed-tools`.
+
+**Under-block risk (Memory):** the verifier checks presence + parseability, not semantic correctness. A syntactically-valid but content-wrong AGENT.md (e.g. missing the identity section) passes verify in v0.1. Acceptable for v0.1 — schema validation deferred. Under-block is loud (logged at sentinel scan time) rather than silent.
+
+**Over-block risk (Memory remediate):** remediate always throws. If a future caller expects auto-fix as the default, this throws instead. Behavior is documented in the spec + in the rule's docstring + in the convergence report. Sentinel-level policy is `flag-only`, so the sentinel will never call remediate on Memory.
+
+## Level-of-abstraction fit
+
+- Tool name mapping: pure data table + tiny renderer. No state, no I/O. Appropriate for the substrate-bound primitive.
+- Memory verifier: pure file I/O + YAML parse + magic-byte check. No mutation. No state.
+- Both rules sit alongside skillParityRule + hookParityRule at the right abstraction layer (per-primitive verifiers consumed by the future FrameworkParitySentinel).
+
+## Signal-vs-authority compliance
+
+- toolNameMapping returns null for unknown — that's a signal to the caller, never a silent permission grant. Caller is the authority.
+- memoryParityRule.verify returns structured mismatches — signal. The sentinel (not yet built) is the authority that decides what to do with the signal.
+- memoryParityRule.remediate refuses unconditionally — this is the rule asserting authority over its own scope (Memory is sacrosanct), consistent with the "Memory is human-authorized" principle in the spec.
+
+## Interaction surface
+
+- Registry: third rule added (`memory`). No interactions with skill or hook rules.
+- toolNameMapping: importable from `src/providers/parity/toolNameMapping.js`. No consumers in v0.1 (intentional — Skill v0.2 wires it).
+- No changes to existing rules, scaffold, hooks, settings.json, or migration paths.
+- No new HTTP routes. No new server-side state.
+
+## Rollback cost
+
+- Pure-add change. Revert is `git revert` on the merge commit. No data migration, no on-disk state created on existing agents, no settings.json mutations, no schema changes.
+- Worst-case bug in Memory verifier: false-positive on existing agents that have unusual but valid Memory artifacts. Mitigation: rule is consumed only by the sentinel (not yet built), so v1.0.4 has zero runtime impact on agents.
+- Worst-case bug in toolNameMapping: a canonical name renders wrong. Mitigation: no callers in v0.1; bug is caught when Skill v0.2 wires in.
+
+## Test coverage
+
+- toolNameMapping: 21 tests covering every entry's cross-framework resolution, MCP prefix handling, unknown-name null return, list ordering, mapping table invariants.
+- memoryParityRule: 18 tests covering required vs optional artifacts, presence checks, empty content, YAML parse errors, unterminated frontmatter, SQLite magic byte verification, remediate-refuses behavior, orphan-empty behavior, rule metadata.
+- registry: updated to assert the 3-rule shape.
+
+## Documentation
+
+- 3 concept specs (Agent, Tool, Memory).
+- 3 ELI16 companions.
+- 6 framework specs (3 × 2 frameworks).
+- 3 convergence reports.
+- NEXT.md updated.
+
+## Deferred (tracked, not silent)
+
+- Agent parity rule (pending Codex subagent surface research) — documented in `specs/instar-concepts/agent.md` "v0.1 deferred items".
+- Skill v0.2 wiring of TOOL_NAME_MAPPING into `allowed-tools` — documented in `specs/instar-concepts/tool.md` + NEXT.md.
+- Memory schema validation beyond YAML-parse — documented in `specs/instar-concepts/memory.md` "v0.1 deferred items".
+- InstructionFile primitive (the loading-vehicle for canonical Memory into framework system prompts) — separate primitive, next.
+- Migration backfill (Memory verifier is no-op on existing agents because canonical Memory already lives in `.instar/` — no migration needed).