@inneranimalmedia/agentsam-sdk 2.6.8 → 2.6.10

package/src/errors/diagnostic.js

@@ -6,7 +6,7 @@ import {
   normalizeError,
   redactErrorValue,
   redactString,
-} from '../../packages/agentsam-errors/src/index.js';
+} from '@inneranimalmedia/agentsam-errors';
 
 const DEFAULT_MAX_DETAIL_CHARS = 12_000;
 function clean(value) { return value == null ? '' : String(value).trim(); }
@@ -181,16 +181,16 @@ export function diagnosticFromError(error, fallback = {}) {
   if (error?.diagnostic) return error.diagnostic;
   const envelope = error?.envelope || (error?.ok === false && error?.schema_version ? error : null);
   if (envelope) return legacyDiagnosticFromEnvelope(envelope, fallback);
-  return Object.freeze({
-    schema_version: 1,
-    source: fallback.source || 'agentsam',
-    kind: fallback.kind || 'runtime_error',
-    code: clean(error?.code || fallback.code) || 'runtime_error',
-    message: redactString(error?.message || error || fallback.message || 'Unknown error', 4_000),
-    http_status: Number(error?.status || fallback.status || 0) || null,
-    retriable: Boolean(fallback.retriable),
-    retry_strategy: fallback.retry_strategy || 'inspect_error',
+  const canonical = normalizeError(error, {
+    reason: fallback.reason,
+    domain: fallback.domain || 'runtime',
+    stage: fallback.stage,
+    feature: fallback.feature,
+    failure_behavior: fallback.failure_behavior,
+    side_effect_state: fallback.side_effect_state,
+    source: { kind: 'runtime', name: fallback.source || 'agentsam-sdk' },
   });
+  return legacyDiagnosticFromEnvelope(canonical, fallback);
 }
 
 export function renderDiagnosticError(error) {

package/src/errors/index.js

@@ -1,4 +1,4 @@
-export * from '../../packages/agentsam-errors/src/index.js';
+export * from '@inneranimalmedia/agentsam-errors';
 
 export {
   AgentSamDiagnosticError,

package/src/index.js

@@ -25,6 +25,37 @@ export {
   suggestCliCommands,
 } from './cli/command-catalog.js';
 export { routeIntent } from './lib/router.js';
+export {
+  HOOK_PROTOCOL_SCHEMA,
+  HOOK_CONFIG_SCHEMA,
+  HOOK_RECEIPT_SCHEMA,
+  HOOK_EVENTS,
+  PERMISSION_DECISIONS,
+  ERROR_HANDLING_DECISIONS,
+  HOOK_FAILURE_MODES,
+  AgentSamHooks,
+  HookExecutionError,
+  HookPermissionError,
+  normalizeHookEvent,
+  normalizeHookOutput,
+  createHookEnvelope,
+  createHookRuntime,
+  createHookRuntimeFromConfig,
+  createHookStore,
+  registerStoredHooks,
+  ensureHookRuntime,
+  findHookConfig,
+  loadHookConfig,
+  createCallbackHookAdapter,
+  createCommandHookAdapter,
+  createHttpHookAdapter,
+  createHookedProviderAdapter,
+  createHookedCapabilityAdapter,
+  createCompositeCapabilityAdapter,
+  createMcpCapabilityAdapter,
+  createLspCapabilityAdapter,
+  createAgentCapabilityAdapter,
+} from '../packages/agentsam-hooks/src/index.js';
 export { searchToolCards, toToolCard, hydrateToolSchemas } from './tools/index.js';
 export {
   AGENTSAM_PLUGIN_SCHEMA_VERSION,
@@ -36,6 +67,7 @@ export {
   listPlugins,
   listPluginTools,
   recordPluginHealthCheck,
+  recordAiPluginModelDiscovery,
   recordToolCall,
   createPluginRuntime,
   createPluginCapabilityAdapter,
@@ -77,6 +109,26 @@ export {
   terminalExec,
 } from './capabilities/index.js';
 export { getPreset, listPresets, resolvePreset, getAddon, listAddons } from './presets/index.js';
+export {
+  LOCAL_ENGINE_SCHEMA,
+  LOCAL_ENGINE_BENCHMARK_SCHEMA,
+  ENGINE_CAPABILITIES,
+  LocalEngineRegistry,
+  createLocalEngineRegistry,
+  createOllamaEngine,
+  createMlxLmEngine,
+  createLlamaCppEngine,
+  auditLocalCompute,
+  auditHost,
+  auditAppleHost,
+  auditTools,
+  auditAssets,
+  adoptAsset,
+  readAssetManifest,
+  assetManifestPath,
+  benchmarkEngine,
+  validateStructuredOutput,
+} from './local-engine/index.js';
 export {
   COMPANY_REPOSITORY_GRAPH_SCHEMA_VERSION,
   REPOSITORY_STATUSES,

package/src/indexing/ingest/materials.js

@@ -1,6 +1,6 @@
 /**
  * Material intake for codebaseindex.ingest — paths pasted/dropped into the CLI.
- * Handles archives (tar/zip), sites/builds, HTML, images, GLB, and mixed trees.
+ * Archives are inspected first and selectively mined instead of blindly unpacked.
  */
 
 import fs from 'node:fs';
@@ -12,6 +12,20 @@ import { isCodeSourceExtension, isDocumentSourceExtension } from '../../../packa
 const ARCHIVE_EXT = new Set(['.zip', '.tar', '.tgz', '.gz', '.tar.gz', '.tbz2', '.tar.bz2']);
 const IMAGE_EXT = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.ico', '.bmp', '.avif']);
 const MODEL_3D_EXT = new Set(['.glb', '.gltf', '.obj', '.fbx', '.stl', '.usdz']);
+const VIDEO_EXT = new Set(['.mp4', '.mov', '.m4v', '.webm', '.mkv', '.avi', '.mpeg', '.mpg']);
+const AUDIO_EXT = new Set(['.mp3', '.wav', '.m4a', '.aac', '.ogg', '.flac']);
+const TEXT_BASENAMES = new Set([
+  'readme', 'license', 'licence', 'dockerfile', 'makefile', 'procfile', 'gemfile', 'rakefile',
+  'cargo.lock', 'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', '.gitignore', '.npmrc', '.editorconfig',
+]);
+const DEFAULT_ARCHIVE_POLICY = Object.freeze({
+  maxEntries: 10_000,
+  maxFiles: 2_000,
+  maxEntryBytes: 8 * 1024 * 1024,
+  maxTotalBytes: 128 * 1024 * 1024,
+  includeAssets: false,
+});
+
 function clean(value) {
   return value == null ? '' : String(value).trim();
 }
@@ -43,9 +57,7 @@ export function parsePastedPaths(text) {
   return [...new Set(paths)];
 }
 
-/**
- * @param {string} filePath
- */
+/** @param {string} filePath */
 export function classifyMaterial(filePath) {
   const resolved = path.resolve(filePath);
   const ext = extOf(resolved);
@@ -79,37 +91,237 @@ function hashFile(filePath) {
 
 function hasBin(name) {
   const result = spawnSync(name, ['--help'], { stdio: 'ignore' });
-  // Some tools exit non-zero on --help; presence of spawn failure matters more.
   return result.error == null;
 }
 
+function archiveFormat(archivePath) {
+  const lower = archivePath.toLowerCase();
+  if (lower.endsWith('.zip')) return 'zip';
+  if (lower.endsWith('.tar') || lower.endsWith('.tar.gz') || lower.endsWith('.tgz')
+    || lower.endsWith('.tar.bz2') || lower.endsWith('.tbz2')) return 'tar';
+  if (lower.endsWith('.gz')) return 'gzip';
+  return null;
+}
+
+function archiveEntryKind(entryPath) {
+  const normalized = String(entryPath || '').replace(/\\/g, '/');
+  const ext = path.posix.extname(normalized.toLowerCase());
+  const base = path.posix.basename(normalized).toLowerCase();
+  if (IMAGE_EXT.has(ext)) return 'image';
+  if (MODEL_3D_EXT.has(ext)) return 'model3d';
+  if (VIDEO_EXT.has(ext)) return 'video';
+  if (AUDIO_EXT.has(ext)) return 'audio';
+  if (isDocumentSourceExtension(ext) || TEXT_BASENAMES.has(base)) return 'document';
+  if (isCodeSourceExtension(ext)) return 'code';
+  return 'file';
+}
+
+function isSafeArchivePath(entryPath) {
+  const raw = String(entryPath || '').replace(/\\/g, '/');
+  if (!raw || raw.includes('\0') || raw.startsWith('/') || /^[a-zA-Z]:\//.test(raw)) return false;
+  const parts = raw.split('/').filter((part) => part && part !== '.');
+  return !parts.includes('..');
+}
+
+function shouldMineArchiveEntry(entry, policy) {
+  if (!entry.safe) return { selected: false, reason: 'unsafe_path' };
+  if (entry.link) return { selected: false, reason: 'link_entry' };
+  if (entry.directory) return { selected: false, reason: 'directory' };
+  if (Number.isFinite(entry.bytes) && entry.bytes > policy.maxEntryBytes) {
+    return { selected: false, reason: 'entry_too_large' };
+  }
+  if (entry.kind === 'code' || entry.kind === 'document') return { selected: true, reason: 'indexable_text' };
+  if (policy.includeAssets && ['image', 'model3d'].includes(entry.kind)) return { selected: true, reason: 'requested_asset' };
+  return { selected: false, reason: ['image', 'model3d', 'video', 'audio'].includes(entry.kind) ? 'asset_inventory_only' : 'non_indexable' };
+}
+
+function commandText(command, args, maxBuffer = 16 * 1024 * 1024) {
+  return execFileSync(command, args, {
+    encoding: 'utf8',
+    maxBuffer,
+    env: { ...process.env, LC_ALL: 'C' },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+function zipSizeMap(archivePath) {
+  if (!hasBin('zipinfo')) return new Map();
+  const map = new Map();
+  const lines = commandText('zipinfo', ['-l', archivePath], 32 * 1024 * 1024).split(/\r?\n/);
+  for (const line of lines) {
+    const match = line.match(/^(\S+)\s+\S+\s+\S+\s+(\d+)\s+\S+\s+\d+\s+\S+\s+\S+\s+\S+\s+(.*)$/);
+    if (!match) continue;
+    map.set(match[3], { bytes: Number(match[2]), link: match[1].startsWith('l') });
+  }
+  return map;
+}
+
 /**
- * Extract archive into destDir. Uses host tar/unzip (no extra npm deps).
+ * Inspect an archive without expanding it to disk.
+ * @param {string} archivePath
+ * @param {Partial<typeof DEFAULT_ARCHIVE_POLICY>} [options]
+ */
+export function inspectArchive(archivePath, options = {}) {
+  const resolved = path.resolve(archivePath);
+  const policy = { ...DEFAULT_ARCHIVE_POLICY, ...options };
+  const format = archiveFormat(resolved);
+  if (!format) throw new Error(`unsupported_archive:${path.basename(resolved)}`);
+  if (!fs.existsSync(resolved)) throw new Error(`archive_missing:${resolved}`);
+
+  let names = [];
+  let zipMeta = new Map();
+  let tarLinks = new Set();
+  if (format === 'zip') {
+    if (!hasBin('unzip')) throw new Error('unzip_unavailable: install unzip to inspect .zip materials');
+    names = commandText('unzip', ['-Z1', resolved], 32 * 1024 * 1024).split(/\r?\n/).filter(Boolean);
+    zipMeta = zipSizeMap(resolved);
+  } else if (format === 'tar') {
+    if (!hasBin('tar')) throw new Error('tar_unavailable: install tar to inspect tar materials');
+    names = commandText('tar', ['-tf', resolved], 32 * 1024 * 1024).split(/\r?\n/).filter(Boolean);
+    const verbose = commandText('tar', ['-tvf', resolved], 32 * 1024 * 1024).split(/\r?\n/);
+    for (const line of verbose) {
+      if (!(line.startsWith('l') || line.startsWith('h'))) continue;
+      const marker = line.includes(' -> ') ? line.split(' -> ')[0] : line;
+      const name = names.find((candidate) => marker.endsWith(candidate));
+      if (name) tarLinks.add(name);
+    }
+  } else {
+    if (!hasBin('gzip')) throw new Error('gzip_unavailable: install gzip to inspect .gz materials');
+    names = [path.basename(resolved, '.gz') || 'payload'];
+  }
+
+  if (names.length > policy.maxEntries) {
+    const error = new Error(`archive_entry_limit_exceeded:${names.length}>${policy.maxEntries}`);
+    error.code = 'AGENTSAM_ARCHIVE_ENTRY_LIMIT';
+    throw error;
+  }
+
+  const entries = names.map((name) => {
+    const meta = zipMeta.get(name) || {};
+    const directory = name.endsWith('/');
+    const entry = {
+      path: name,
+      bytes: Number.isFinite(meta.bytes) ? meta.bytes : null,
+      kind: directory ? 'directory' : archiveEntryKind(name),
+      directory,
+      link: Boolean(meta.link || tarLinks.has(name)),
+      safe: isSafeArchivePath(name),
+    };
+    return { ...entry, ...shouldMineArchiveEntry(entry, policy) };
+  });
+
+  const unsafe = entries.filter((entry) => !entry.safe);
+  if (unsafe.length) {
+    const error = new Error(`archive_unsafe_paths:${unsafe.slice(0, 5).map((entry) => entry.path).join(',')}`);
+    error.code = 'AGENTSAM_ARCHIVE_UNSAFE_PATH';
+    throw error;
+  }
+
+  const selected = entries.filter((entry) => entry.selected);
+  const selectedKnownBytes = selected.reduce((sum, entry) => sum + (entry.bytes || 0), 0);
+  const byKind = {};
+  for (const entry of entries) byKind[entry.kind] = (byKind[entry.kind] || 0) + 1;
+
+  return {
+    schema: 'agentsam.archive.inspect.v1',
+    archive: resolved,
+    format,
+    compressed_bytes: fs.statSync(resolved).size,
+    entries_total: entries.length,
+    selected_total: selected.length,
+    selected_known_bytes: selectedKnownBytes,
+    by_kind: byKind,
+    policy,
+    entries,
+  };
+}
+
+function readArchiveEntry(archivePath, format, entry, maxBytes) {
+  const maxBuffer = Math.max(1024 * 1024, maxBytes + 1);
+  if (format === 'zip') {
+    return execFileSync('unzip', ['-p', archivePath, entry], { encoding: null, maxBuffer, stdio: ['ignore', 'pipe', 'pipe'] });
+  }
+  if (format === 'tar') {
+    return execFileSync('tar', ['-xOf', archivePath, entry], { encoding: null, maxBuffer, stdio: ['ignore', 'pipe', 'pipe'] });
+  }
+  return execFileSync('gzip', ['-dc', archivePath], { encoding: null, maxBuffer, stdio: ['ignore', 'pipe', 'pipe'] });
+}
+
+/**
+ * Selectively mine indexable content from an archive into destDir.
+ * Large/binary/media members remain represented in the receipt but are not copied.
  * @param {string} archivePath
  * @param {string} destDir
+ * @param {Partial<typeof DEFAULT_ARCHIVE_POLICY>} [options]
  */
-export function extractArchive(archivePath, destDir) {
+export function extractArchive(archivePath, destDir, options = {}) {
+  const policy = { ...DEFAULT_ARCHIVE_POLICY, ...options };
+  const inspection = inspectArchive(archivePath, policy);
+  fs.rmSync(destDir, { recursive: true, force: true });
   fs.mkdirSync(destDir, { recursive: true });
-  const lower = archivePath.toLowerCase();
-  if (lower.endsWith('.zip')) {
-    if (!hasBin('unzip')) throw new Error('unzip_unavailable: install unzip to extract .zip materials');
-    execFileSync('unzip', ['-q', '-o', archivePath, '-d', destDir], { stdio: ['ignore', 'pipe', 'pipe'] });
-    return { tool: 'unzip', dest: destDir };
-  }
-  if (lower.endsWith('.tar') || lower.endsWith('.tar.gz') || lower.endsWith('.tgz')
-    || lower.endsWith('.tar.bz2') || lower.endsWith('.tbz2') || lower.endsWith('.gz')) {
-    if (!hasBin('tar')) throw new Error('tar_unavailable: install tar to extract archive materials');
-    execFileSync('tar', ['-xf', archivePath, '-C', destDir], { stdio: ['ignore', 'pipe', 'pipe'] });
-    return { tool: 'tar', dest: destDir };
+
+  const selected = inspection.entries.filter((entry) => entry.selected);
+  const mined = [];
+  const skipped = inspection.entries.filter((entry) => !entry.selected).map((entry) => ({
+    path: entry.path, kind: entry.kind, bytes: entry.bytes, reason: entry.reason,
+  }));
+  let totalBytes = 0;
+
+  for (const entry of selected) {
+    if (mined.length >= policy.maxFiles) {
+      skipped.push({ path: entry.path, kind: entry.kind, bytes: entry.bytes, reason: 'file_limit' });
+      continue;
+    }
+    if (Number.isFinite(entry.bytes) && totalBytes + entry.bytes > policy.maxTotalBytes) {
+      skipped.push({ path: entry.path, kind: entry.kind, bytes: entry.bytes, reason: 'total_byte_limit' });
+      continue;
+    }
+
+    let payload;
+    try {
+      payload = readArchiveEntry(inspection.archive, inspection.format, entry.path, policy.maxEntryBytes);
+    } catch (cause) {
+      skipped.push({ path: entry.path, kind: entry.kind, bytes: entry.bytes, reason: 'extract_error', error: String(cause?.message || cause).slice(0, 240) });
+      continue;
+    }
+    if (payload.length > policy.maxEntryBytes || totalBytes + payload.length > policy.maxTotalBytes) {
+      skipped.push({ path: entry.path, kind: entry.kind, bytes: payload.length, reason: payload.length > policy.maxEntryBytes ? 'entry_too_large' : 'total_byte_limit' });
+      continue;
+    }
+
+    const normalized = entry.path.replace(/\\/g, '/').replace(/^\.\//, '');
+    const output = path.resolve(destDir, ...normalized.split('/'));
+    const root = path.resolve(destDir);
+    if (!(output === root || output.startsWith(`${root}${path.sep}`))) {
+      throw new Error(`archive_unsafe_output:${entry.path}`);
+    }
+    fs.mkdirSync(path.dirname(output), { recursive: true });
+    fs.writeFileSync(output, payload);
+    totalBytes += payload.length;
+    mined.push({ path: entry.path, kind: entry.kind, bytes: payload.length });
   }
-  throw new Error(`unsupported_archive:${path.basename(archivePath)}`);
+
+  return {
+    schema: 'agentsam.archive.mine.v1',
+    format: inspection.format,
+    dest: destDir,
+    entries_total: inspection.entries_total,
+    mined_files: mined.length,
+    mined_bytes: totalBytes,
+    skipped_files: skipped.length,
+    by_kind: inspection.by_kind,
+    policy,
+    mined,
+    skipped: skipped.slice(0, 200),
+    skipped_truncated: skipped.length > 200,
+  };
 }
 
 /**
  * Stage pasted/dropped materials under `.agentsam/ingest/<id>/`.
- * Archives are extracted; files/dirs are copied or linked by relative include paths.
+ * Archives are inspected + selectively mined; files/dirs are copied or linked by relative include paths.
  *
- * @param {{ root: string, materials: string[], ingestId?: string }} opts
+ * @param {{ root: string, materials: string[], ingestId?: string, archivePolicy?: object }} opts
  */
 export function stageMaterials(opts) {
   const root = path.resolve(opts.root);
@@ -117,11 +329,8 @@ export function stageMaterials(opts) {
   const stageRoot = path.join(root, '.agentsam', 'ingest', ingestId);
   fs.mkdirSync(stageRoot, { recursive: true });
 
-  /** @type {object[]} */
   const items = [];
-  /** @type {string[]} */
   const include = [];
-  /** @type {object[]} */
   const assets = [];
 
   for (const raw of opts.materials) {
@@ -133,11 +342,10 @@ export function stageMaterials(opts) {
 
     if (classified.kind === 'archive') {
       const dest = path.join(stageRoot, 'archives', path.basename(classified.path, classified.ext) || 'archive');
-      fs.mkdirSync(dest, { recursive: true });
-      const extracted = extractArchive(classified.path, dest);
+      const extracted = extractArchive(classified.path, dest, opts.archivePolicy || {});
       const rel = path.relative(root, dest);
-      include.push(rel);
-      items.push({ ...classified, status: 'extracted', stage: dest, extract: extracted });
+      if (extracted.mined_files > 0) include.push(rel);
+      items.push({ ...classified, status: 'mined', stage: dest, extract: extracted });
       continue;
     }
 
@@ -158,7 +366,6 @@ export function stageMaterials(opts) {
       continue;
     }
 
-    // Single file
     const destDir = path.join(stageRoot, classified.kind === 'image' ? 'images'
       : classified.kind === 'model3d' ? 'models3d'
         : classified.kind === 'document' ? 'documents'
@@ -180,7 +387,7 @@ export function stageMaterials(opts) {
 
   const uniqueInclude = [...new Set(include.map((p) => p.replace(/\\/g, '/').replace(/\/$/, '') || '.'))].sort();
   const manifest = {
-    schema: 'agentsam.ingest.materials.v1',
+    schema: 'agentsam.ingest.materials.v2',
     ingest_id: ingestId,
     staged_at: new Date().toISOString(),
     stage_root: path.relative(root, stageRoot),

package/src/knowledge/service/grpc-codec.js

@@ -77,6 +77,7 @@ export function encodeErrorDetail(value) {
   detail.setDomain(envelope.domain);
   if (envelope.tool) detail.setTool(envelope.tool);
   if (envelope.stage) detail.setStage(envelope.stage);
+  if (envelope.native_stage) detail.setNativeStage(envelope.native_stage);
   detail.setRemediationAction(envelope.remediation.action);
   if (envelope.remediation.message) detail.setRemediationMessage(envelope.remediation.message);
   detail.setFingerprint(envelope.fingerprint);
@@ -115,6 +116,7 @@ export function decodeErrorDetail(detail) {
     domain: detail.hasDomain?.() ? detail.getDomain() : 'runtime',
     tool: detail.hasTool?.() ? detail.getTool() : null,
     stage: detail.hasStage?.() ? detail.getStage() : null,
+    native_stage: detail.hasNativeStage?.() ? detail.getNativeStage() : null,
     remediation: {
       action: detail.hasRemediationAction?.() ? detail.getRemediationAction() : undefined,
       message: detail.hasRemediationMessage?.() ? detail.getRemediationMessage() : null,

package/src/lib/setup/runtime.js

@@ -380,14 +380,16 @@ export function renderRuntimePlan(plan) {
         lines.push(`      missing tools: ${c.constraints.missing_tools.join(', ')}`);
       }
     } else if (c.goap.action_ids.length) {
-      lines.push(`      plan: ${c.goap.action_ids.join(' → ')}`);
+      lines.push(`      target plan: ${c.goap.action_ids.join(' → ')}`);
     }
   }
   lines.push('');
   if (plan.recommended) {
     lines.push(`  Recommended  ${plan.recommended.profile.label} (${plan.recommended.profile.id})`);
     lines.push(`  Next         agentsam setup runtime --profile ${plan.recommended.profile.id} --yes`);
-    lines.push(`               agentsam runtime install`);
+    lines.push(plan.facts.agentsamd.installed
+      ? '               agentsam runtime status'
+      : '               agentsam runtime install');
   }
   lines.push('');
   return `${lines.join('\n')}\n`;

package/src/lib/slash-commands.js

@@ -12,6 +12,7 @@ export const SLASH_COMMANDS = [
   { cmd: '/context', description: 'Show model context economics; add repo for Git bridge context', lane: 'context' },
   { cmd: '/status', description: 'Honest project awareness: account, models, terminal, live deploy', lane: 'local' },
   { cmd: '/models', description: 'Probe providers and provider-verified known models', lane: 'model' },
+  { cmd: '/hooks', description: 'Inspect lifecycle hook sources, order, and execution receipts', lane: 'agent' },
   { cmd: '/providers', description: 'Configure and verify machine provider credentials', lane: 'model' },
   { cmd: '/credentials', description: 'Audit credentials, drift, and remediation (never prints secrets)', lane: 'identity' },
   { cmd: '/cheat-sheet', description: 'Organized Agent Sam command groups', lane: 'local' },

package/src/local/runtime-store.js

@@ -4,6 +4,7 @@ import { createLocalSqliteDatabase } from './sqlite.js';
 import { applyRuntimeMigrations } from './migrations.js';
 import { findCliProjectRoot } from '../lib/cli-preferences.js';
 import { getLocalDatabasePath, tryReadProjectConfig } from '../lib/project-config.js';
+import { createHookStore } from '../../packages/agentsam-hooks/src/store.js';
 
 function clean(value) { return value == null ? '' : String(value).trim(); }
 function hash(value) { return createHash('sha256').update(String(value || '')).digest('hex'); }
@@ -187,3 +188,48 @@ export async function pruneExpiredRuntimeState(value = {}) {
     return { digests: Number(digests.changes || 0), compactions: Number(compactions.changes || 0), approvals_expired: Number(approvals.changes || 0) };
   });
 }
+
+function hookStore(db, value = {}) {
+  return createHookStore(db, { ownerId: clean(value.owner_id || value.account_id) || 'local' });
+}
+
+export async function listRuntimeHooks(value = {}) {
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).listHooks({
+    activeOnly: value.activeOnly,
+    event_type: value.event_type,
+    context: value.context,
+  }));
+}
+
+export async function upsertRuntimeHook(value = {}) {
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).upsertHook(value));
+}
+
+export async function setRuntimeHookActive(value = {}) {
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).setHookActive(value.hook_id || value.hook_key, value.active));
+}
+
+export async function removeRuntimeHook(value = {}) {
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).removeHook(value.hook_id || value.hook_key));
+}
+
+export async function recordRuntimeHookReceipt(value = {}) {
+  if (!value.receipt) return null;
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).recordExecution(value.receipt, {
+    source_kind: value.source_kind,
+    hook_id: value.hook_id,
+    invocation_id: value.invocation_id,
+    agent_run_id: value.agent_run_id,
+    session_id: value.session_id,
+    conversation_id: value.conversation_id,
+    context: value.context,
+  }));
+}
+
+export async function listRuntimeHookExecutions(value = {}) {
+  return withStore(value.projectRoot || value.cwd, (db) => hookStore(db, value).listExecutions({
+    hook_key: value.hook_key,
+    status: value.status,
+    limit: value.limit,
+  }));
+}

package/src/local-engine/assets.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+export const ASSET_MANIFEST_SCHEMA = 'agentsam.local-model-assets.v1';
+export function agentsamHome(env = process.env) {
+  const configured = String(env.AGENTSAM_HOME || '').trim();
+  return configured ? path.resolve(configured.replace(/^~(?=\/|$)/, os.homedir())) : path.join(os.homedir(), '.agentsam');
+}
+export function assetManifestPath(env = process.env) { return path.join(agentsamHome(env), 'models', 'manifest.v1.json'); }
+function safeStat(file) { try { return fs.statSync(file); } catch { return null; } }
+function fileId(stat) { return stat ? `${stat.dev}:${stat.ino}` : null; }
+export function readAssetManifest(env = process.env) {
+  const file = assetManifestPath(env);
+  if (!fs.existsSync(file)) return { schema_version: ASSET_MANIFEST_SCHEMA, generated_at: null, assets: [] };
+  try { const parsed = JSON.parse(fs.readFileSync(file, 'utf8')); return parsed?.schema_version === ASSET_MANIFEST_SCHEMA ? parsed : { schema_version: ASSET_MANIFEST_SCHEMA, generated_at: null, assets: [] }; } catch { return { schema_version: ASSET_MANIFEST_SCHEMA, generated_at: null, assets: [] }; }
+}
+function writeManifest(manifest, env = process.env) {
+  const file = assetManifestPath(env); fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`; fs.writeFileSync(temp, JSON.stringify(manifest, null, 2) + '\n', { mode: 0o600 }); fs.renameSync(temp, file); return file;
+}
+export function adoptAsset(file, metadata = {}, options = {}) {
+  const absolute = path.resolve(file); const stat = safeStat(absolute);
+  if (!stat || !stat.isFile()) throw new Error(`model asset is not a regular file: ${absolute}`);
+  const env = options.env || process.env; const manifest = readAssetManifest(env);
+  const asset = { id: metadata.id || crypto.createHash('sha256').update(`${absolute}:${stat.size}:${stat.mtimeMs}`).digest('hex').slice(0, 16), engine_id: metadata.engine_id || null, model: metadata.model || path.basename(absolute), format: metadata.format || path.extname(absolute).slice(1) || 'unknown', canonical_path: absolute, reference: 'external', size_bytes: stat.size, file_id: fileId(stat), digest: metadata.digest || null, seen_at: new Date().toISOString() };
+  const assets = manifest.assets.filter((row) => row.canonical_path !== absolute); assets.push(asset);
+  const next = { ...manifest, schema_version: ASSET_MANIFEST_SCHEMA, generated_at: new Date().toISOString(), assets }; const manifestPath = writeManifest(next, env);
+  return { asset, manifest_path: manifestPath, copied: false };
+}
+export function auditAssets(options = {}) {
+  const env = options.env || process.env; const manifest = readAssetManifest(env);
+  const assets = manifest.assets.map((asset) => { const stat = safeStat(asset.canonical_path); return { ...asset, exists: Boolean(stat), current_size_bytes: stat?.size || null, current_file_id: fileId(stat), stale: !stat || stat.size !== asset.size_bytes }; });
+  const byFile = new Map(); for (const asset of assets) if (asset.file_id) byFile.set(asset.file_id, [...(byFile.get(asset.file_id) || []), asset.id]);
+  return { schema_version: ASSET_MANIFEST_SCHEMA, generated_at: new Date().toISOString(), root: path.join(agentsamHome(env), 'models'), assets, duplicates: [...byFile.entries()].filter(([, ids]) => ids.length > 1).map(([file_id, ids]) => ({ file_id, asset_ids: ids })) };
+}