instar 0.28.117 → 0.28.118

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.118",
   "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:06:04.451Z",
+  "instarVersion": "0.28.118",
   "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/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).