@inneranimalmedia/agentsam-sdk 2.6.10 → 2.6.12

package/packages/agentsam-contracts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-contracts",
-  "version": "2.6.10",
+  "version": "2.6.12",
   "description": "Framework-neutral AgentSam contracts for workbench, tools, providers, events, hooks, execution, identity and repository context.",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,6 +17,10 @@
       "types": "./dist/events.d.ts",
       "import": "./dist/events.js"
     },
+    "./run": {
+      "types": "./dist/run.d.ts",
+      "import": "./dist/run.js"
+    },
     "./tools": {
       "types": "./dist/tools.d.ts",
       "import": "./dist/tools.js"
@@ -64,6 +68,10 @@
     "./errors": {
       "types": "./dist/errors.d.ts",
       "import": "./dist/errors.js"
+    },
+    "./widgets": {
+      "types": "./dist/widgets.d.ts",
+      "import": "./dist/widgets.js"
     }
   },
   "scripts": {

package/packages/agentsam-contracts/scripts/build.mjs

@@ -4,7 +4,7 @@ import { fileURLToPath } from 'node:url';
 import { build } from 'esbuild';
 
 const cwd = fileURLToPath(new URL('../', import.meta.url));
-const modules = ['index','agent','events','tools','authority','execution','providers','hooks','artifacts','context','adapter','models','identity','repository','errors'];
+const modules = ['index','agent','events','run','tools','authority','execution','providers','hooks','artifacts','context','adapter','models','identity','repository','errors','widgets'];
 rmSync(`${cwd}/dist`, { recursive: true, force: true });
 await build({
   absWorkingDir: cwd,

package/packages/agentsam-contracts/src/agent.ts

@@ -22,14 +22,89 @@ export interface AgentInput {
   capabilityIds?: string[];
 }
 
-export type AgentRunStatus = 'queued' | 'running' | 'completed' | 'cancelled' | 'failed';
+export type AgentRunMode = 'ask' | 'plan' | 'agent' | 'debug' | 'multitask';
+
+export type AgentRunSelectedBy = 'manual' | 'automatic' | 'fallback';
+
+export type AgentRunStatus =
+  | 'queued'
+  | 'running'
+  | 'paused'
+  | 'waiting_external'
+  | 'waiting_child'
+  | 'awaiting_input'
+  | 'awaiting_approval'
+  | 'sleeping'
+  | 'retry_scheduled'
+  | 'partial'
+  | 'completed'
+  | 'cancelled'
+  | 'failed'
+  | 'timed_out';
+
+export type AgentRunTerminalStatus = 'completed' | 'cancelled' | 'failed' | 'timed_out';
+
+export type AgentRunWaitingStatus =
+  | 'waiting_external'
+  | 'waiting_child'
+  | 'awaiting_input'
+  | 'awaiting_approval'
+  | 'sleeping'
+  | 'retry_scheduled';
 
 export interface AgentRun {
   id: string;
-  conversationId: string;
+  conversationId?: string;
   status: AgentRunStatus;
-  startedAt: number;
+  startedAt?: number;
   completedAt?: number;
+
+  accountId?: string;
+  kind?: string;
+  externalAgentId?: string;
+  externalRunId?: string;
+  parentRunId?: string;
+  sourceClient?: string;
+  surface?: string;
+  mode?: AgentRunMode;
   modelId?: string;
+  modelKey?: string;
+  reasoningEffort?: string;
+  requestedServiceTier?: string;
+  actualServiceTier?: string;
+  selectedBy?: AgentRunSelectedBy;
+  cancelRequested?: boolean;
+  errorCode?: string;
+  errorMessage?: string;
   error?: string;
+  modelCallCount?: number;
+  toolCallCount?: number;
+  inputTokens?: number;
+  cachedInputTokens?: number;
+  outputTokens?: number;
+  reasoningTokens?: number;
+  costUsd?: number;
+  createdAt?: number;
+  updatedAt?: number;
+  latencyMs?: number;
+  planId?: string;
+  todoId?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export function isAgentRunTerminalStatus(status: AgentRunStatus): status is AgentRunTerminalStatus {
+  return status === 'completed' || status === 'cancelled' || status === 'failed' || status === 'timed_out';
+}
+
+export function isAgentRunWaitingStatus(status: AgentRunStatus): status is AgentRunWaitingStatus {
+  return status === 'waiting_external'
+    || status === 'waiting_child'
+    || status === 'awaiting_input'
+    || status === 'awaiting_approval'
+    || status === 'sleeping'
+    || status === 'retry_scheduled';
+}
+
+export function isAgentRunModelActiveStatus(status: AgentRunStatus): boolean {
+  return status === 'queued' || status === 'running';
 }

package/packages/agentsam-contracts/src/index.ts

@@ -1,5 +1,6 @@
 export * from './agent';
 export * from './events';
+export * from './run';
 export * from './tools';
 export * from './authority';
 export * from './execution';
@@ -12,3 +13,4 @@ export * from './models';
 export * from './identity';
 export * from './repository';
 export * from './errors';
+export * from './widgets';

package/packages/agentsam-contracts/src/run.ts

@@ -0,0 +1,320 @@
+import type { AgentRunStatus } from './agent';
+
+export type AgentRunSuspensionReason =
+  | 'external'
+  | 'child_run'
+  | 'approval'
+  | 'input'
+  | 'retry'
+  | 'scheduled'
+  | 'rate_limit';
+
+export interface AgentRunSuspension {
+  runId: string;
+  state:
+    | 'waiting_external'
+    | 'waiting_child'
+    | 'awaiting_input'
+    | 'awaiting_approval'
+    | 'sleeping'
+    | 'retry_scheduled';
+  reason: AgentRunSuspensionReason;
+  wakeAt?: number;
+  wakeEvent?: string;
+  dependencyRunIds?: string[];
+  attempt?: number;
+  resumeStepId?: string;
+  checkpointRef?: string;
+  expiresAt?: number;
+  metadata?: Record<string, unknown>;
+}
+
+export type AgentRunWakeKind = 'event' | 'dependency' | 'scheduled' | 'manual';
+
+export interface AgentRunWakeSignal {
+  id: string;
+  runId: string;
+  kind: AgentRunWakeKind;
+  occurredAt: number;
+  dedupeKey: string;
+  eventKey?: string;
+  dependencyRunId?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export type AgentRunRetryClass = 'transient' | 'wait' | 'replan' | 'terminal';
+
+export interface AgentRunRetryClassificationInput {
+  code?: string | null;
+  statusCode?: number | null;
+  retryable?: boolean | null;
+}
+
+export interface AgentRunRetryClassification {
+  class: AgentRunRetryClass;
+  automaticRetry: boolean;
+  reason: string;
+}
+
+const WAIT_CODES = new Set([
+  'approval_required',
+  'input_required',
+  'external_pending',
+  'dependency_pending',
+]);
+
+const REPLAN_CODES = new Set([
+  'precondition_failed',
+  'repository_changed',
+  'capability_unavailable',
+]);
+
+const TRANSIENT_CODES = new Set([
+  'timeout',
+  'request_timeout',
+  'rate_limited',
+  'provider_unavailable',
+  'runtime_unavailable',
+  'econnreset',
+  'econnrefused',
+  'etimedout',
+  'eai_again',
+]);
+
+export function classifyAgentRunRetry(input: AgentRunRetryClassificationInput = {}): AgentRunRetryClassification {
+  const code = String(input.code || '').trim().toLowerCase();
+  const statusCode = Number(input.statusCode);
+
+  if (input.retryable === true) {
+    return { class: 'transient', automaticRetry: true, reason: code || 'explicit_retryable' };
+  }
+  if (input.retryable === false) {
+    return { class: 'terminal', automaticRetry: false, reason: code || 'explicit_non_retryable' };
+  }
+  if (WAIT_CODES.has(code)) {
+    return { class: 'wait', automaticRetry: false, reason: code };
+  }
+  if (REPLAN_CODES.has(code)) {
+    return { class: 'replan', automaticRetry: false, reason: code };
+  }
+  if (TRANSIENT_CODES.has(code) || [408, 425, 429, 500, 502, 503, 504].includes(statusCode)) {
+    return { class: 'transient', automaticRetry: true, reason: code || `http_${statusCode}` };
+  }
+  return { class: 'terminal', automaticRetry: false, reason: code || 'unclassified_failure' };
+}
+
+export type AgentRunWakeDecisionReason =
+  | 'accepted'
+  | 'duplicate'
+  | 'run_mismatch'
+  | 'expired'
+  | 'condition_not_met';
+
+export interface AgentRunWakeDecision {
+  accepted: boolean;
+  reason: AgentRunWakeDecisionReason;
+  nextStatus?: 'queued';
+}
+
+export function evaluateAgentRunWake(
+  suspension: AgentRunSuspension,
+  wake: AgentRunWakeSignal,
+  options: { consumedDedupeKeys?: Iterable<string>; now?: number } = {},
+): AgentRunWakeDecision {
+  const consumed = new Set(options.consumedDedupeKeys || []);
+  if (consumed.has(wake.dedupeKey)) return { accepted: false, reason: 'duplicate' };
+  if (suspension.runId !== wake.runId) return { accepted: false, reason: 'run_mismatch' };
+
+  const now = options.now ?? wake.occurredAt;
+  if (suspension.expiresAt != null && now > suspension.expiresAt) {
+    return { accepted: false, reason: 'expired' };
+  }
+
+  const matched = wake.kind === 'manual'
+    || Boolean(suspension.wakeEvent && wake.eventKey === suspension.wakeEvent)
+    || Boolean(
+      wake.kind === 'dependency'
+      && wake.dependencyRunId
+      && (suspension.dependencyRunIds || []).includes(wake.dependencyRunId),
+    )
+    || Boolean(wake.kind === 'scheduled' && suspension.wakeAt != null && now >= suspension.wakeAt);
+
+  return matched
+    ? { accepted: true, reason: 'accepted', nextStatus: 'queued' }
+    : { accepted: false, reason: 'condition_not_met' };
+}
+
+export function wakeMatchesSuspension(
+  suspension: AgentRunSuspension,
+  wake: AgentRunWakeSignal,
+  now = wake.occurredAt,
+): boolean {
+  return evaluateAgentRunWake(suspension, wake, { now }).accepted;
+}
+
+export type AgentRunLifecycleAction =
+  | { type: 'start' }
+  | { type: 'suspend'; status: AgentRunSuspension['state'] }
+  | { type: 'wake' }
+  | { type: 'complete' }
+  | { type: 'fail' }
+  | { type: 'cancel' }
+  | { type: 'timeout' };
+
+export function transitionAgentRunStatus(status: AgentRunStatus, action: AgentRunLifecycleAction): AgentRunStatus {
+  if (status === 'completed' || status === 'failed' || status === 'cancelled' || status === 'timed_out') {
+    return status;
+  }
+  if (action.type === 'cancel') return 'cancelled';
+  if (action.type === 'timeout') return 'timed_out';
+  if (action.type === 'complete') return 'completed';
+  if (action.type === 'fail') return 'failed';
+  if (action.type === 'suspend') return action.status;
+  if (action.type === 'wake') return 'queued';
+  if (action.type === 'start') return 'running';
+  return status;
+}
+
+export type AgentRunEventType =
+  | 'run.created'
+  | 'run.queued'
+  | 'run.started'
+  | 'run.status'
+  | 'run.suspended'
+  | 'run.woken'
+  | 'run.cancel_requested'
+  | 'run.cancelled'
+  | 'run.timed_out'
+  | 'run.failed'
+  | 'run.completed'
+  | 'step.started'
+  | 'step.progress'
+  | 'step.completed'
+  | 'decision.made'
+  | 'tool.started'
+  | 'tool.completed'
+  | 'artifact.created'
+  | 'file.changed'
+  | 'approval.required'
+  | 'input.required'
+  | 'verification.completed'
+  | (string & {});
+
+export type AgentActivityPhase =
+  | 'boot'
+  | 'observe'
+  | 'context'
+  | 'plan'
+  | 'execute'
+  | 'verify'
+  | 'compact'
+  | 'waiting'
+  | 'recover'
+  | 'complete';
+
+export type AgentActivityEventType =
+  | 'run.started'
+  | 'phase.changed'
+  | 'step.started'
+  | 'step.progress'
+  | 'step.completed'
+  | 'decision.made'
+  | 'tool.started'
+  | 'tool.completed'
+  | 'artifact.created'
+  | 'file.changed'
+  | 'approval.required'
+  | 'input.required'
+  | 'verification.completed'
+  | 'run.failed'
+  | 'run.completed';
+
+export interface AgentRunEvent {
+  id: string;
+  runId: string;
+  parentRunId?: string;
+  seq: number;
+  eventType: AgentRunEventType;
+  status?: AgentRunStatus;
+  phase?: AgentActivityPhase;
+  stepId?: string;
+  label?: string;
+  detail?: string | null;
+  progress?: { current: number; total: number } | null;
+  source?: { kind?: string; name?: string | null } | null;
+  evidence?: Record<string, unknown> | null;
+  createdAt: number;
+}
+
+export interface AgentActivityEventV1 {
+  schema: 'agentsam.activity.v1';
+  run_id: string;
+  seq: number;
+  timestamp: string;
+  phase: AgentActivityPhase;
+  event: AgentActivityEventType;
+  step_id: string | null;
+  parent_id: string | null;
+  label: string;
+  detail: string | null;
+  progress: { current: number; total: number } | null;
+  source: { kind: string; name: string | null };
+  evidence: Record<string, unknown> | null;
+}
+
+function phaseForRunEvent(event: AgentRunEvent): AgentActivityPhase {
+  if (event.phase) return event.phase;
+  if (event.eventType === 'run.created' || event.eventType === 'run.queued' || event.eventType === 'run.started') return 'boot';
+  if (event.eventType === 'run.suspended') return 'waiting';
+  if (event.eventType === 'run.woken' || event.eventType === 'run.cancel_requested') return 'recover';
+  if (event.eventType === 'verification.completed') return 'verify';
+  if (event.eventType === 'run.completed' || event.eventType === 'run.cancelled' || event.eventType === 'run.timed_out') return 'complete';
+  if (event.eventType === 'run.failed') return 'complete';
+  return 'execute';
+}
+
+function activityTypeForRunEvent(event: AgentRunEvent): AgentActivityEventType {
+  if (event.eventType === 'run.started') return 'run.started';
+  if (event.eventType === 'run.completed') return 'run.completed';
+  if (event.eventType === 'run.failed' || event.eventType === 'run.timed_out') return 'run.failed';
+  if (event.eventType === 'run.cancelled' || event.eventType === 'run.suspended' || event.eventType === 'run.woken' || event.eventType === 'run.status' || event.eventType === 'run.cancel_requested' || event.eventType === 'run.created' || event.eventType === 'run.queued') return 'phase.changed';
+  if (event.eventType === 'step.started') return 'step.started';
+  if (event.eventType === 'step.completed') return 'step.completed';
+  if (event.eventType === 'decision.made') return 'decision.made';
+  if (event.eventType === 'tool.started') return 'tool.started';
+  if (event.eventType === 'tool.completed') return 'tool.completed';
+  if (event.eventType === 'artifact.created') return 'artifact.created';
+  if (event.eventType === 'file.changed') return 'file.changed';
+  if (event.eventType === 'approval.required') return 'approval.required';
+  if (event.eventType === 'input.required') return 'input.required';
+  if (event.eventType === 'verification.completed') return 'verification.completed';
+  return 'step.progress';
+}
+
+export function projectRunEventToActivity(event: AgentRunEvent): AgentActivityEventV1 {
+  const evidence = {
+    ...(event.evidence || {}),
+    run_event_id: event.id,
+    run_event_type: event.eventType,
+    ...(event.status ? { run_status: event.status } : {}),
+  };
+
+  return {
+    schema: 'agentsam.activity.v1',
+    run_id: event.runId,
+    seq: event.seq,
+    timestamp: new Date(event.createdAt).toISOString(),
+    phase: phaseForRunEvent(event),
+    event: activityTypeForRunEvent(event),
+    step_id: event.stepId ?? null,
+    parent_id: event.parentRunId ?? null,
+    label: event.label || '',
+    detail: event.detail ?? null,
+    progress: event.progress ?? null,
+    source: {
+      kind: event.source?.kind || 'sam',
+      name: event.source?.name ?? null,
+    },
+    evidence,
+  };
+}

package/packages/agentsam-contracts/src/widgets.ts

@@ -0,0 +1,58 @@
+import type { AgentSamErrorEnvelope } from './errors';
+
+export type AgentSamWidgetSize = 'small' | 'medium' | 'large';
+
+export type AgentSamWidgetKind =
+  | 'countdown'
+  | 'clock'
+  | 'metric'
+  | 'list'
+  | 'launcher'
+  | 'brand'
+  | (string & {});
+
+export interface AgentSamWidgetDataSource {
+  /** Existing route key, tool operation id, or host-owned projection id. */
+  source: string;
+  /** Host-defined refresh class, such as realtime, short, medium, or manual. */
+  refresh?: string;
+}
+
+export interface AgentSamWidgetDefinition {
+  id: string;
+  kind: AgentSamWidgetKind;
+  title: string;
+  description?: string;
+  icon?: string;
+  sizes: readonly AgentSamWidgetSize[];
+  data?: AgentSamWidgetDataSource;
+  /** Route key or host-resolved deep link. Do not put credentials or raw provider secrets here. */
+  deeplink?: string;
+}
+
+export interface AgentSamWidgetReadyState {
+  status: 'ready';
+  updated_at?: string;
+}
+
+export interface AgentSamWidgetStaleState {
+  status: 'stale';
+  updated_at: string;
+  error: AgentSamErrorEnvelope;
+}
+
+export interface AgentSamWidgetEmptyState {
+  status: 'empty';
+  updated_at?: string;
+}
+
+export interface AgentSamWidgetErrorState {
+  status: 'error';
+  error: AgentSamErrorEnvelope;
+}
+
+export type AgentSamWidgetState =
+  | AgentSamWidgetReadyState
+  | AgentSamWidgetStaleState
+  | AgentSamWidgetEmptyState
+  | AgentSamWidgetErrorState;

package/packages/agentsam-contracts/test/contracts.test.mjs

@@ -10,7 +10,7 @@ test('contracts package stays framework neutral', async () => {
 
 test('execution-plane contracts are exported as first-class package surfaces', async () => {
   const pkg = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
-  for (const key of ['./tools', './authority', './execution', './providers', './events', './hooks']) {
+  for (const key of ['./tools', './authority', './execution', './providers', './events', './run', './hooks', './widgets']) {
     const entry = pkg.exports[key];
     assert.equal(typeof entry, 'object', `missing typed contract export: ${key}`);
     assert.match(entry.types, /^\.\/dist\/.+\.d\.ts$/);

package/packages/agentsam-contracts/test/run-contract.test.mjs

@@ -0,0 +1,94 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  classifyAgentRunRetry,
+  evaluateAgentRunWake,
+  isAgentRunModelActiveStatus,
+  isAgentRunTerminalStatus,
+  isAgentRunWaitingStatus,
+  projectRunEventToActivity,
+  transitionAgentRunStatus,
+} from '../dist/index.js';
+
+test('run lifecycle distinguishes model-active, waiting, and terminal states', () => {
+  assert.equal(isAgentRunModelActiveStatus('running'), true);
+  assert.equal(isAgentRunModelActiveStatus('waiting_external'), false);
+  assert.equal(isAgentRunWaitingStatus('waiting_child'), true);
+  assert.equal(isAgentRunTerminalStatus('timed_out'), true);
+  assert.equal(isAgentRunTerminalStatus('partial'), false);
+
+  assert.equal(transitionAgentRunStatus('queued', { type: 'start' }), 'running');
+  assert.equal(transitionAgentRunStatus('running', { type: 'suspend', status: 'waiting_external' }), 'waiting_external');
+  assert.equal(transitionAgentRunStatus('waiting_external', { type: 'wake' }), 'queued');
+  assert.equal(transitionAgentRunStatus('running', { type: 'cancel' }), 'cancelled');
+  assert.equal(transitionAgentRunStatus('running', { type: 'timeout' }), 'timed_out');
+  assert.equal(transitionAgentRunStatus('completed', { type: 'wake' }), 'completed');
+});
+
+test('wake evaluation is deterministic and rejects duplicate wake signals', () => {
+  const suspension = {
+    runId: 'run_parent',
+    state: 'waiting_child',
+    reason: 'child_run',
+    dependencyRunIds: ['run_child'],
+    expiresAt: 2_000,
+  };
+  const wake = {
+    id: 'wake_1',
+    runId: 'run_parent',
+    kind: 'dependency',
+    dependencyRunId: 'run_child',
+    occurredAt: 1_000,
+    dedupeKey: 'child:run_child:complete',
+  };
+
+  assert.deepEqual(evaluateAgentRunWake(suspension, wake), {
+    accepted: true,
+    reason: 'accepted',
+    nextStatus: 'queued',
+  });
+  assert.deepEqual(evaluateAgentRunWake(suspension, wake, {
+    consumedDedupeKeys: [wake.dedupeKey],
+  }), {
+    accepted: false,
+    reason: 'duplicate',
+  });
+  assert.equal(evaluateAgentRunWake(suspension, { ...wake, dependencyRunId: 'other' }).accepted, false);
+  assert.equal(evaluateAgentRunWake(suspension, { ...wake, occurredAt: 2_001 }, { now: 2_001 }).reason, 'expired');
+});
+
+test('retry classification only auto-retries transient failures', () => {
+  assert.deepEqual(classifyAgentRunRetry({ statusCode: 429 }), {
+    class: 'transient',
+    automaticRetry: true,
+    reason: 'http_429',
+  });
+  assert.equal(classifyAgentRunRetry({ code: 'approval_required' }).class, 'wait');
+  assert.equal(classifyAgentRunRetry({ code: 'repository_changed' }).class, 'replan');
+  assert.equal(classifyAgentRunRetry({ code: 'permission_denied' }).automaticRetry, false);
+});
+
+test('append-only run events project to agentsam.activity.v1 without losing provenance', () => {
+  const projected = projectRunEventToActivity({
+    id: 'evt_42',
+    runId: 'run_parent',
+    parentRunId: 'run_root',
+    seq: 42,
+    eventType: 'run.suspended',
+    status: 'waiting_external',
+    label: 'Waiting for deployment',
+    detail: 'Provider job is still pending',
+    createdAt: Date.parse('2026-10-03T07:00:00.000Z'),
+    source: { kind: 'queue', name: 'deployments' },
+    evidence: { provider_job_id: 'dep_123' },
+  });
+
+  assert.equal(projected.schema, 'agentsam.activity.v1');
+  assert.equal(projected.phase, 'waiting');
+  assert.equal(projected.event, 'phase.changed');
+  assert.equal(projected.parent_id, 'run_root');
+  assert.equal(projected.evidence.run_event_id, 'evt_42');
+  assert.equal(projected.evidence.run_event_type, 'run.suspended');
+  assert.equal(projected.evidence.run_status, 'waiting_external');
+});

package/packages/agentsam-errors/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-errors",
-  "version": "2.6.10",
+  "version": "2.6.12",
   "description": "Canonical AgentSam runtime error normalization, classification, transport, remediation and rendering.",
   "type": "module",
   "main": "./src/index.js",

package/packages/agentsam-goap/README.md

@@ -50,3 +50,6 @@ The Memory adapter is the conformance/reference adapter. The D1/SQLite adapter t
 Portable ticket_events rows carry account_id and repository_id directly. The older platform host table does not. Set eventOwnership to ticket_join for that legacy shape; it scopes events through their owning ticket without requiring a second event table or a duplicate-column migration.
 
 Blackboard ownership is adapter-specific. Use blackboardOwnership=repository for account-owned portable/local stores. Shared hosts must verify repository ownership instead of trusting caller scope; IAM D1 uses blackboardOwnership=repository_join, which checks code_repositories.account_id on blackboard reads and CAS writes.
+
+<!-- agentsam:trademark-notice -->
+> Independent project. Not affiliated with, endorsed by, or sponsored by Cloudflare, Inc. or by any other company whose products are named here. Cloudflare is a registered trademark of Cloudflare, Inc. Other names are trademarks of their respective owners. See [TRADEMARKS](https://github.com/SamPrimeaux/agentsam-sdk/blob/main/TRADEMARKS.md).

package/packages/agentsam-goap/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-goap",
-  "version": "2.6.10",
+  "version": "2.6.12",
   "description": "Portable AgentSam GOAP control-plane contracts and adapters over existing blackboard, ticket, workflow, execution, approval, queue, runtime, and evidence stores.",
   "type": "module",
   "main": "./src/index.js",
@@ -20,7 +20,7 @@
     "test": "node --test test/*.test.mjs"
   },
   "dependencies": {
-    "@inneranimalmedia/agentsam-errors": "2.6.10"
+    "@inneranimalmedia/agentsam-errors": "2.6.12"
   },
   "engines": {
     "node": ">=22 <25"

package/packages/agentsam-hooks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-hooks",
-  "version": "2.6.10",
+  "version": "2.6.12",
   "description": "Provider-neutral, language-agnostic AgentSam lifecycle hooks with callback, command, HTTP, model, tool, MCP, LSP, and sub-agent adapters.",
   "type": "module",
   "main": "./src/index.js",
@@ -32,7 +32,7 @@
     "./protocol/receipt": "./protocol/agentsam.hook.receipt.v1.schema.json"
   },
   "bin": {
-    "agentsam-hooks": "./bin/agentsam-hooks.mjs"
+    "agentsam-hooks": "bin/agentsam-hooks.mjs"
   },
   "files": [
     "bin",