@inneranimalmedia/agentsam-sdk 2.6.7 → 2.6.9

package/packages/agentsam-goap/src/world.js

@@ -0,0 +1,202 @@
+import {
+  GOAP_SCHEMAS,
+  normalizeActionSpec,
+  normalizeBlackboard,
+  normalizeGoal,
+} from './contracts.js';
+import { goapInputError } from './errors.js';
+
+const TODO_TO_GOAL_STATUS = Object.freeze({
+  open: 'proposed',
+  running: 'active',
+  blocked: 'blocked',
+  complete: 'satisfied',
+  cancelled: 'cancelled',
+});
+
+const PRIORITY_COST = Object.freeze({
+  critical: 1,
+  high: 2,
+  medium: 3,
+  low: 4,
+});
+
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+function array(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function object(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function taskById(plan) {
+  return new Map(array(plan?.tasks).map((task) => [task.id, task]));
+}
+
+function blockersFor(plan, task) {
+  const byId = taskById(plan);
+  return array(task?.metadata?.depends_on)
+    .map((id) => byId.get(id) || { id, title: null, status: 'missing' })
+    .filter((dependency) => dependency.status !== 'complete')
+    .map((dependency) => ({
+      id: dependency.id,
+      title: dependency.title || null,
+      status: dependency.status,
+    }));
+}
+
+export function projectPlanActions(plan = {}) {
+  const available = [];
+  const blocked = [];
+
+  for (const task of array(plan.tasks)) {
+    if (task.status !== 'open') continue;
+    const blockers = blockersFor(plan, task);
+    const action = {
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      spec: normalizeActionSpec({
+        preconditions: array(task.metadata?.depends_on).map((todoId) => ({
+          fact: 'todo.complete',
+          todo_id: todoId,
+          value: true,
+        })),
+        effects: [{
+          fact: 'todo.complete',
+          todo_id: task.id,
+          value: true,
+        }],
+        cost: PRIORITY_COST[task.priority] ?? 3,
+        metadata: {
+          kind: task.metadata?.kind || 'work',
+          priority: task.priority || 'medium',
+          sort_order: Number(task.sort_order ?? 50),
+        },
+      }),
+    };
+
+    if (blockers.length) blocked.push({ ...action, blockers });
+    else available.push(action);
+  }
+
+  return { available, blocked };
+}
+
+export function projectGoapWorld({
+  repository = {},
+  plan,
+  activeTodo = null,
+  actions = null,
+  knowledge = {},
+  evidence = null,
+  accountId = null,
+  revision = 1,
+  updatedAt = null,
+} = {}) {
+  const repositoryId = clean(repository.repository_id ?? repository.repositoryId);
+  if (!repositoryId) {
+    throw goapInputError('repository.repository_id is required for GOAP world projection', {
+      stage: 'project_world',
+      details: { field: 'repository.repository_id' },
+    });
+  }
+  if (!plan?.id) {
+    throw goapInputError('plan.id is required for GOAP world projection', {
+      stage: 'project_world',
+      details: { field: 'plan.id' },
+    });
+  }
+
+  const projectedActions = actions || projectPlanActions(plan);
+  const todo = activeTodo || null;
+  const goalId = todo?.id || plan.id;
+  const goalTitle = todo?.title || plan.title || plan.id;
+  const goalStatus = todo
+    ? (TODO_TO_GOAL_STATUS[todo.status] || 'proposed')
+    : (Number(plan.tasks_done || 0) === Number(plan.tasks_total || -1) ? 'satisfied' : 'active');
+
+  const state = {
+    plan: {
+      id: plan.id,
+      title: plan.title || null,
+      status: plan.status || null,
+      tasks_done: Number(plan.tasks_done || 0),
+      tasks_total: Number(plan.tasks_total || array(plan.tasks).length),
+    },
+    todo: todo ? {
+      id: todo.id,
+      title: todo.title || null,
+      status: todo.status || null,
+      priority: todo.priority || null,
+      kind: todo.metadata?.kind || 'work',
+      depends_on: array(todo.metadata?.depends_on),
+      acceptance: array(todo.metadata?.acceptance),
+      evidence: array(todo.metadata?.evidence),
+    } : null,
+    repository: {
+      repository_id: repositoryId,
+      branch: repository.branch || null,
+      revision_sha: repository.revision_sha || repository.revisionSha || null,
+      dirty: repository.dirty ?? null,
+      merkle_root: repository.merkle_root || null,
+    },
+    knowledge: { ...object(knowledge) },
+    actions: projectedActions,
+    evidence: evidence || null,
+  };
+
+  const blackboard = normalizeBlackboard({
+    id: 'world:' + repositoryId,
+    account_id: clean(accountId) || null,
+    repository_id: repositoryId,
+    current_goal_id: goalId,
+    state,
+    revision,
+    locked_by: 'project_local_plan',
+    checkpoint_sha: repository.revision_sha || repository.revisionSha || null,
+    last_action: 'world_snapshot_projected',
+    updated_at: updatedAt,
+  });
+
+  const goal = normalizeGoal({
+    id: goalId,
+    account_id: clean(accountId),
+    repository_id: repositoryId,
+    title: goalTitle,
+    goal_status: goalStatus,
+    priority: todo?.priority || null,
+    spec: {
+      desired: [{
+        fact: todo ? 'todo.complete' : 'plan.complete',
+        [todo ? 'todo_id' : 'plan_id']: goalId,
+        value: true,
+      }],
+      constraints: array(todo?.metadata?.depends_on).map((todoId) => ({
+        fact: 'todo.complete',
+        todo_id: todoId,
+        value: true,
+      })),
+      metadata: {
+        source: 'project_local_plan',
+        plan_id: plan.id,
+        todo_id: todo?.id || null,
+      },
+    },
+    updated_at: updatedAt,
+  });
+
+  return {
+    schema: GOAP_SCHEMAS.world,
+    source: 'project_local_plan',
+    repository_id: repositoryId,
+    blackboard,
+    goal,
+    actions: projectedActions,
+    evidence: evidence || null,
+  };
+}

package/packages/agentsam-goap/test/goap-control-plane.test.mjs

@@ -0,0 +1,245 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { DatabaseSync } from 'node:sqlite';
+import {
+  AgentSamError,
+  ERROR_REASON,
+  planRecovery,
+} from '@inneranimalmedia/agentsam-errors';
+import {
+  GOAP_SCHEMAS,
+  MemoryGoapAdapter,
+  createD1SqliteGoapAdapter,
+  createGoapControlPlane,
+  goalStatusFromTicket,
+  ticketStatusFromGoal,
+} from '../src/index.js';
+
+const scope = {
+  account_id: 'acct_test',
+  repository_id: 'github:example/repo',
+  workspace_id: 'ws_test',
+};
+
+test('status mapping preserves database statuses while exposing logical GOAP states', () => {
+  assert.equal(goalStatusFromTicket('backlog'), 'proposed');
+  assert.equal(goalStatusFromTicket('in_review'), 'verifying');
+  assert.equal(ticketStatusFromGoal('satisfied'), 'shipped');
+});
+
+test('memory adapter atomically activates goal with CAS and append-only cursor', async () => {
+  const adapter = new MemoryGoapAdapter({
+    blackboards: [{
+      ...scope,
+      id: 'bb_1',
+      current_goal_id: null,
+      state: { build: { valid: false } },
+      revision: 4,
+    }],
+    goals: [{
+      ...scope,
+      id: 'tkt_1',
+      title: 'Make build valid',
+      status: 'backlog',
+      goal_spec_json: { desired: [{ fact: 'build.valid', op: 'eq', value: true }] },
+    }],
+  });
+
+  const service = createGoapControlPlane({ ports: adapter.ports(), clock: () => 100 });
+  const activated = await service.activateGoal({
+    scope,
+    goalId: 'tkt_1',
+    expectedRevision: 4,
+    actor: { type: 'test', id: 'runner' },
+  });
+
+  assert.equal(activated.blackboard.revision, 5);
+  assert.equal(activated.blackboard.current_goal_id, 'tkt_1');
+  assert.equal(activated.goal.status, 'active');
+  assert.equal(activated.events.length, 1);
+  assert.equal(activated.events[0].type, 'goal.activated');
+  assert.equal(activated.events[0].payload.blackboard_revision, 5);
+  assert.match(activated.events[0].cursor, /^memory:/);
+
+  await assert.rejects(
+    service.activateGoal({ scope, goalId: 'tkt_1', expectedRevision: 4 }),
+    (error) => {
+      assert.equal(error instanceof AgentSamError, true);
+      assert.equal(error.reason, ERROR_REASON.STALE_VERSION);
+      assert.equal(error.code, 'ABORTED');
+      assert.equal(error.envelope.tool, 'goap');
+      assert.equal(planRecovery(error.envelope).disposition, 'retry');
+      return true;
+    },
+  );
+});
+
+function d1Like(db) {
+  return {
+    prepare(sql) {
+      const statement = db.prepare(sql);
+      return {
+        bind(...values) {
+          return {
+            async first() {
+              return statement.get(...values) ?? null;
+            },
+            async all() {
+              return { results: statement.all(...values) };
+            },
+            async run() {
+              return statement.run(...values);
+            },
+          };
+        },
+      };
+    },
+    async batch(statements) {
+      db.exec('BEGIN IMMEDIATE');
+      try {
+        const results = [];
+        for (const statement of statements) results.push(await statement.run());
+        db.exec('COMMIT');
+        return results;
+      } catch (error) {
+        try { db.exec('ROLLBACK'); } catch {}
+        throw error;
+      }
+    },
+  };
+}
+
+function createSqlite({ eventOwnership = true } = {}) {
+  const sqlite = new DatabaseSync(':memory:');
+  const eventOwnershipColumns = eventOwnership ? 'account_id TEXT, repository_id TEXT,' : '';
+  sqlite.exec([
+    'CREATE TABLE agentsam_workspace_state (',
+    'id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, repository_id TEXT NOT NULL,',
+    'current_task_id TEXT, state_json TEXT NOT NULL DEFAULT \'{}\',',
+    'state_schema TEXT NOT NULL DEFAULT \'agentsam.blackboard.v1\',',
+    'revision INTEGER NOT NULL DEFAULT 1, locked_by TEXT, lock_expires_at INTEGER,',
+    'checkpoint_sha TEXT, last_agent_action TEXT, updated_at INTEGER NOT NULL);',
+    'CREATE TABLE agentsam_tickets (',
+    'id TEXT PRIMARY KEY, title TEXT NOT NULL, status TEXT NOT NULL, priority TEXT,',
+    'account_id TEXT NOT NULL, repository_id TEXT NOT NULL, goal_schema TEXT,',
+    'goal_spec_json TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL);',
+    'CREATE TABLE agentsam_ticket_events (',
+    'id TEXT PRIMARY KEY, ticket_id TEXT NOT NULL, event_type TEXT NOT NULL, detail TEXT,',
+    'created_at INTEGER NOT NULL, actor_type TEXT, actor_id TEXT, ' + eventOwnershipColumns,
+    'payload_json TEXT NOT NULL DEFAULT \'{}\', workflow_run_id TEXT, execution_step_id TEXT,',
+    'schema_version TEXT NOT NULL DEFAULT \'agentsam.event.v1\');',
+  ].join('\n'));
+  sqlite.prepare(
+    'INSERT INTO agentsam_workspace_state ' +
+    '(id, workspace_id, repository_id, current_task_id, state_json, revision, updated_at) ' +
+    'VALUES (?, ?, ?, NULL, \'{}\', 7, 1)',
+  ).run('bb_sql', scope.workspace_id, scope.repository_id);
+  sqlite.prepare(
+    'INSERT INTO agentsam_tickets ' +
+    '(id, title, status, account_id, repository_id, goal_schema, goal_spec_json, created_at, updated_at) ' +
+    'VALUES (?, ?, \'backlog\', ?, ?, ?, ?, 1, 1)',
+  ).run(
+    'tkt_sql',
+    'Ship portable GOAP',
+    scope.account_id,
+    scope.repository_id,
+    GOAP_SCHEMAS.goal,
+    JSON.stringify({ schema: GOAP_SCHEMAS.goal, desired: [] }),
+  );
+  return sqlite;
+}
+
+
+test('repository_join blackboard ownership rejects cross-account reads on shared stores', async () => {
+  const sqlite = createSqlite();
+  sqlite.exec(
+    'CREATE TABLE code_repositories (id TEXT PRIMARY KEY, account_id TEXT NOT NULL);',
+  );
+  sqlite.prepare(
+    'INSERT INTO code_repositories (id, account_id) VALUES (?, ?)',
+  ).run(scope.repository_id, scope.account_id);
+
+  const ports = createD1SqliteGoapAdapter({
+    db: d1Like(sqlite),
+    blackboardOwnership: 'repository_join',
+  });
+
+  const owned = await ports.blackboardStore.get(scope);
+  assert.equal(owned.repository_id, scope.repository_id);
+
+  const foreign = await ports.blackboardStore.get({
+    ...scope,
+    account_id: 'acct_other',
+  });
+  assert.equal(foreign, null);
+
+  sqlite.close();
+});
+
+test('D1/SQLite adapter atomically guards stale revisions with canonical AgentSam errors', async () => {
+  const sqlite = createSqlite();
+  const ports = createD1SqliteGoapAdapter({ db: d1Like(sqlite) });
+  const service = createGoapControlPlane({ ports, clock: () => 1234 });
+
+  await assert.rejects(
+    service.activateGoal({ scope, goalId: 'tkt_sql', expectedRevision: 6 }),
+    (error) => {
+      assert.equal(error instanceof AgentSamError, true);
+      assert.equal(error.reason, ERROR_REASON.STALE_VERSION);
+      assert.equal(error.envelope.domain, 'tool');
+      assert.equal(error.envelope.tool, 'goap');
+      return true;
+    },
+  );
+
+  assert.equal(sqlite.prepare('SELECT revision FROM agentsam_workspace_state').get().revision, 7);
+  assert.equal(sqlite.prepare('SELECT status FROM agentsam_tickets').get().status, 'backlog');
+  assert.equal(sqlite.prepare('SELECT COUNT(*) AS n FROM agentsam_ticket_events').get().n, 0);
+
+  const result = await service.activateGoal({
+    scope,
+    goalId: 'tkt_sql',
+    expectedRevision: 7,
+    actor: { type: 'test', id: 'sqlite' },
+  });
+
+  assert.equal(result.blackboard.revision, 8);
+  assert.equal(result.blackboard.current_goal_id, 'tkt_sql');
+  assert.equal(result.goal.status, 'active');
+  assert.equal(result.events[0].type, 'goal.activated');
+  assert.match(result.events[0].cursor, /^sqlite:/);
+
+  const eventRow = sqlite.prepare(
+    'SELECT account_id, repository_id, payload_json, schema_version FROM agentsam_ticket_events LIMIT 1',
+  ).get();
+  assert.equal(eventRow.account_id, scope.account_id);
+  assert.equal(eventRow.repository_id, scope.repository_id);
+  assert.equal(eventRow.schema_version, GOAP_SCHEMAS.event);
+  assert.equal(JSON.parse(eventRow.payload_json).blackboard_revision, 8);
+
+  sqlite.close();
+});
+
+test('ticket_join event ownership supports the legacy platform event table', async () => {
+  const sqlite = createSqlite({ eventOwnership: false });
+  const ports = createD1SqliteGoapAdapter({
+    db: d1Like(sqlite),
+    eventOwnership: 'ticket_join',
+    cursorPrefix: 'd1',
+  });
+  const service = createGoapControlPlane({ ports, clock: () => 2000 });
+
+  const result = await service.activateGoal({
+    scope,
+    goalId: 'tkt_sql',
+    expectedRevision: 7,
+  });
+
+  assert.equal(result.blackboard.revision, 8);
+  assert.equal(result.goal.status, 'active');
+  assert.equal(result.events.length, 1);
+  assert.match(result.events[0].cursor, /^d1:/);
+  assert.equal(sqlite.prepare('SELECT COUNT(*) AS n FROM agentsam_ticket_events').get().n, 1);
+
+  sqlite.close();
+});

package/packages/agentsam-goap/test/world.test.mjs

@@ -0,0 +1,79 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { projectGoapWorld, projectPlanActions } from '../src/world.js';
+
+const plan = {
+  id: 'plan_1',
+  title: 'Ship portable loop',
+  status: 'active',
+  tasks_done: 1,
+  tasks_total: 3,
+  tasks: [
+    {
+      id: 'todo_done',
+      title: 'Freeze contract',
+      status: 'complete',
+      priority: 'high',
+      sort_order: 10,
+      metadata: { kind: 'decision', depends_on: [] },
+    },
+    {
+      id: 'todo_active',
+      title: 'Project world',
+      status: 'running',
+      priority: 'critical',
+      sort_order: 20,
+      metadata: { kind: 'implement', depends_on: ['todo_done'], acceptance: [], evidence: [] },
+    },
+    {
+      id: 'todo_next',
+      title: 'Verify loop',
+      status: 'open',
+      priority: 'high',
+      sort_order: 30,
+      metadata: { kind: 'verify', depends_on: ['todo_active'] },
+    },
+  ],
+};
+
+test('projectPlanActions converts TODO dependencies into GOAP preconditions', () => {
+  const actions = projectPlanActions(plan);
+  assert.equal(actions.available.length, 0);
+  assert.equal(actions.blocked.length, 1);
+  assert.equal(actions.blocked[0].id, 'todo_next');
+  assert.equal(actions.blocked[0].blockers[0].id, 'todo_active');
+  assert.deepEqual(actions.blocked[0].spec.preconditions[0], {
+    fact: 'todo.complete',
+    todo_id: 'todo_active',
+    value: true,
+  });
+});
+
+test('projectGoapWorld emits canonical world, blackboard, goal, and action contracts', () => {
+  const world = projectGoapWorld({
+    repository: {
+      repository_id: 'github:example/repo',
+      branch: 'main',
+      revision_sha: 'abc123',
+      dirty: false,
+      merkle_root: 'sha256:merkle',
+    },
+    plan,
+    activeTodo: plan.tasks[1],
+    knowledge: { status: 'current', generation_id: 'gen_1' },
+    evidence: { primitive: 'repository.audit', chars: 900 },
+    revision: 7,
+    updatedAt: 123,
+  });
+
+  assert.equal(world.schema, 'agentsam.goap.world.v1');
+  assert.equal(world.blackboard.schema, 'agentsam.blackboard.v1');
+  assert.equal(world.blackboard.current_goal_id, 'todo_active');
+  assert.equal(world.blackboard.revision, 7);
+  assert.equal(world.blackboard.state.repository.merkle_root, 'sha256:merkle');
+  assert.equal(world.goal.schema, 'agentsam.goal.v1');
+  assert.equal(world.goal.id, 'todo_active');
+  assert.equal(world.goal.status, 'active');
+  assert.equal(world.goal.spec.desired[0].fact, 'todo.complete');
+  assert.equal(world.actions.blocked[0].id, 'todo_next');
+});

package/packages/agentsam-knowledge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-knowledge",
-  "version": "2.6.7",
+  "version": "2.6.9",
   "description": "Portable AutoRAG discovery, adapter registries, probes, and company routing contracts for AgentSam.",
   "type": "module",
   "exports": {
@@ -25,5 +25,6 @@
   },
   "files": [
     "src"
-  ]
+  ],
+  "license": "MIT"
 }

package/packages/agentsam-nav/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-nav",
-  "version": "2.6.7",
+  "version": "2.6.9",
   "private": false,
   "description": "Reusable responsive navigation primitives for AgentSam dashboard-family applications.",
   "type": "module",

package/packages/agentsam-queue-control/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-queue-control",
-  "version": "2.6.7",
+  "version": "2.6.9",
   "description": "Portable AgentSam queue, job-routing, batching, and execution-control primitives with Cloudflare-first adapters.",
   "type": "module",
   "main": "./src/index.js",

package/packages/agentsam-rapid-rust/src/main.rs

@@ -14,6 +14,7 @@ const COMPATIBILITY_DATE: &str = "2026-09-27";
 #[derive(Parser, Debug)]
 #[command(
     name = "agentsam-rapid-rust",
+    bin_name = "agentsam rust",
     version,
     about = "Scaffold, teach, verify, build, and explicitly deploy Cloudflare Rust/Wasm Workers"
 )]

package/packages/agentsam-repository/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-repository",
-  "version": "2.6.7",
+  "version": "2.6.9",
   "description": "Portable AgentSam repository identity, Merkle, semantic file metadata, persistence, and repository graph runtime contracts.",
   "type": "module",
   "main": "./src/index.js",
@@ -31,5 +31,6 @@
   },
   "files": [
     "src"
-  ]
+  ],
+  "license": "MIT"
 }

package/packages/agentsam-repository/src/goap.js

@@ -5,7 +5,6 @@ import { execFileSync } from 'node:child_process';
 import { tryResolveGitContext } from './git-context.js';
 import {
   createTicketId,
-  createAgentRunId,
   generateTicketCreateSql,
   generateTicketCloseSql,
 } from './tickets.js';
@@ -252,7 +251,6 @@ export async function createGoapGoal({
   if (!accId) throw new Error('account_id_required');
 
   const ticketId = createTicketId();
-  const agentRunId = createAgentRunId();
   const now = Math.floor(Date.now() / 1000);
 
   const { sql: ticketSql } = generateTicketCreateSql({
@@ -268,7 +266,6 @@ export async function createGoapGoal({
     repositoryId: repoId,
     ownerRef: repoId,
     source: 'agentsam_sdk',
-    agentRunId,
     now,
   });
 
@@ -305,7 +302,7 @@ ON CONFLICT(repository_id) DO UPDATE SET
   return {
     ok: true,
     ticketId,
-    agentRunId,
+    agentRunId: null,
     title: cleanTitle,
     status,
     priority,
@@ -338,23 +335,17 @@ export async function switchGoapGoal({
     query,
     wranglerConfig,
     databaseName,
-    sql: `SELECT id, account_id, repository_id FROM agentsam_tickets WHERE id = '${sqlEsc(tid)}' LIMIT 1;`,
+    sql: `SELECT id, account_id, repository_id, agent_run_id FROM agentsam_tickets WHERE id = '${sqlEsc(tid)}' LIMIT 1;`,
   });
   const ticket = lookup?.[0]?.results?.[0];
   const accId = clean(accountId);
   if (!ticket) throw new Error('ticket_not_found');
   if (ticket.repository_id && ticket.repository_id !== repoId) throw new Error('ticket_repository_mismatch');
   if (!accId || ticket.account_id !== accId) throw new Error('ticket_account_mismatch');
-  const runId = createAgentRunId();
 
   const sql = `
-INSERT INTO agentsam_agent_run (
-  id, account_id, mode, status, started_at_unix, created_at_unix, updated_at_unix
-) VALUES ('${sqlEsc(runId)}', '${sqlEsc(accId)}', 'agent', 'running', ${now}, ${now}, ${now});
-
 UPDATE agentsam_tickets SET
   status = 'active',
-  agent_run_id = '${sqlEsc(runId)}',
   updated_at = ${now}
 WHERE id = '${sqlEsc(tid)}';
 
@@ -385,7 +376,7 @@ ON CONFLICT(repository_id) DO UPDATE SET
     ok: true,
     ticketId: tid,
     repositoryId: repoId,
-    agentRunId: runId,
+    agentRunId: ticket.agent_run_id || null,
   };
 }
 
@@ -420,7 +411,7 @@ export async function closeGoapGoal({
     query,
     wranglerConfig,
     databaseName,
-    sql: `SELECT id, account_id, repository_id FROM agentsam_tickets WHERE id = '${sqlEsc(tid)}' LIMIT 1;`,
+    sql: `SELECT id, account_id, repository_id, agent_run_id FROM agentsam_tickets WHERE id = '${sqlEsc(tid)}' LIMIT 1;`,
   });
   const ticket = lookup?.[0]?.results?.[0];
   const accId = clean(accountId);
@@ -471,6 +462,8 @@ export function renderGoapStatus(state = {}) {
   const cp = state.cursor || {};
   const git = state.git || {};
   const headSha = git?.revisionSha || git?.headSha || 'unknown';
+  const localPlan = state.localPlan || null;
+  const world = state.worldSnapshot || null;
 
   return [
     '================================================================================',
@@ -487,6 +480,12 @@ export function renderGoapStatus(state = {}) {
     `Checkpoint:    ${ws.checkpoint_sha ? ws.checkpoint_sha.slice(0, 10) : 'none'} (Tracker cursor: ${cp.last_sha ? cp.last_sha.slice(0, 10) : 'none'})`,
     `Last Action:   ${ws.last_agent_action || 'none'}`,
     `Updated:       ${formatDate(ws.updated_at || ticket.updated_at)}`,
+    ...(localPlan ? [
+      `Plan:          ${localPlan.title} (${localPlan.tasks_done}/${localPlan.tasks_total})`,
+      `World:         ${world?.snapshot_id || 'local'} · Merkle ${world?.merkle_root ? world.merkle_root.slice(0, 20) + '…' : 'unknown'}`,
+      `Knowledge:     ${world?.knowledge_freshness?.status || 'unknown'}${world?.knowledge_freshness?.reason ? ' (' + world.knowledge_freshness.reason + ')' : ''}`,
+      `Actions:       ${world?.actions?.available?.length || 0} available · ${world?.actions?.blocked?.length || 0} blocked`,
+    ] : []),
     '--------------------------------------------------------------------------------',
     ...(!ticket.id && !ws.current_task_id ? [
       '  No active goal. What are you trying to achieve?',
@@ -499,7 +498,7 @@ export function renderGoapStatus(state = {}) {
       : ['  (no commits ingested yet)']),
     ...(state.stepsUnavailable
       ? ['--------------------------------------------------------------------------------',
-         '  (note: step/plan linkage unavailable — agentsam_plans has no agent_run_id column yet)']
+         '  (note: remote step/plan linkage is unavailable for this repository)']
       : []),
     '================================================================================',
   ].join('\n');