@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.4

package/src/commands/shell.js

@@ -13,25 +13,38 @@ import { runModels } from './models.js';
 import { runProviders } from './providers.js';
 import { configureCliPreferences } from './preferences.js';
 import { runCloudflare } from './cloudflare.js';
+import { runConnections } from './connections.js';
+import { runTunnel } from './tunnel.js';
 import { probeOllamaModel, resolveOllamaConfig } from './ollama.js';
 import { createInlineActivity } from '../ui/cli/activity.js';
 import { createCliRuntimePresenter } from '../ui/cli/runtime-events.js';
-import { renderCliFooter } from '../ui/cli/footer.js';
+import { renderCliFooter, renderDiffPreview, renderUsagePanel } from '../ui/cli/footer.js';
 import { diagnosticFromError, renderDiagnosticError } from '../errors/index.js';
-import { getModelRecord } from '../models/index.js';
+import { getModelRecord, mergeModelReference, listModelCatalog } from '../models/index.js';
 import { discoverProviderModels } from '../models/discovery.js';
-import { readCliPreferences, updateCliPreferences } from '../lib/cli-preferences.js';
+import { detectCliProject, findCliProjectRoot, readCliPreferences, updateCliPreferences } from '../lib/cli-preferences.js';
 import { buildContextEconomicsReport, renderContextEconomics } from './context-economics.js';
 import { createProviderAdapter } from '../providers/index.js';
 import { createCapabilityAdapter, runResponsesAgent } from '../agent/index.js';
 import { resolveProviderCredential } from '../lib/provider-credentials.js';
-import { createLocalSession, saveLocalSession, sessionTitleFromInput, localSessionElapsedMs } from '../lib/local-sessions.js';
+import { createLocalSession, saveLocalSession, localSessionElapsedMs, loadSessionContinuation } from '../lib/local-sessions.js';
+import { runtimeDatabasePath } from '../local/runtime-store.js';
 import { grantExecutionApproval, isExecutionApproved, toolApprovalKey } from '../lib/execution-approvals.js';
 import { runWhoami } from './whoami.js';
 import { runLogin, runLogout } from './account-auth.js';
 import { runHelp } from '../ui/cli/help.js';
+import { hydrateSecureCredentials } from '../security/local-vault.js';
 import { readAccountSession } from '../lib/account-session.js';
 import { startRuntimeRun, finishRuntimeRun, recordRuntimeCompaction } from '../local/runtime-store.js';
+import { tryResolveGitContext } from '../../packages/agentsam-repository/src/git-context.js';
+import { syncWorkspaceStateToD1, readWorkspaceStateFromD1 } from '../../packages/agentsam-repository/src/workspace-state.js';
+import { syncGitCommitsToD1 } from '../../packages/agentsam-repository/src/work-tracking.js';
+import { readGoapState, listGoapTickets, createGoapGoal, switchGoapGoal, closeGoapGoal, renderGoapStatus, renderGoapList, renderGoapGoal, renderGoapWhy, renderGoapPlan } from '../../packages/agentsam-repository/src/goap.js';
+import { SkillRegistry, SkillRuntime, SkillContentResolver } from '../skills/index.js';
+import {
+  presentAgentSamInteraction,
+  handleSkillInteractionChoice,
+} from './interaction-clack.js';
 
 function writeLine(write, value = '') { write(`${value}\n`); }
 
@@ -54,6 +67,134 @@ export function renderShellPrompt(cwd, env = process.env) {
   return `${shellUsername(env)} ${compactCwd(cwd, env.HOME || env.USERPROFILE || '')} > `;
 }
 
+export const PASTE_COLLAPSE_LINE_THRESHOLD = 5;
+export const PASTE_COLLAPSE_CHAR_THRESHOLD = 300;
+const BRACKETED_PASTE_START = '\x1b[200~';
+const BRACKETED_PASTE_END = '\x1b[201~';
+const BRACKETED_PASTE_ENABLE = '\x1b[?2004h';
+const BRACKETED_PASTE_DISABLE = '\x1b[?2004l';
+
+export function countPasteLines(text) {
+  const source = String(text ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  if (!source) return 0;
+  const parts = source.split('\n');
+  if (parts[parts.length - 1] === '') parts.pop();
+  return Math.max(parts.length, source ? 1 : 0);
+}
+
+export function shouldCollapsePaste(text) {
+  const source = String(text ?? '');
+  return countPasteLines(source) > PASTE_COLLAPSE_LINE_THRESHOLD || source.length > PASTE_COLLAPSE_CHAR_THRESHOLD;
+}
+
+export function renderCollapsedPaste(text) {
+  return `[Pasted ${countPasteLines(text)} lines — Enter to run, Backspace to clear]`;
+}
+
+export function installPasteCollapse(rl, options = {}) {
+  if (!rl || rl.terminal === false || typeof rl._ttyWrite !== 'function') return () => {};
+  const original = rl._ttyWrite.bind(rl);
+  let collapsed = null;
+  let collecting = '';
+  let inPaste = false;
+
+  function refresh(line) {
+    rl.line = line;
+    rl.cursor = line.length;
+    if (typeof rl._refreshLine === 'function') rl._refreshLine();
+  }
+
+  function showCollapsed(text) {
+    collapsed = text;
+    refresh(renderCollapsedPaste(text));
+  }
+
+  function consumePaste(body) {
+    inPaste = false;
+    collecting = '';
+    if (shouldCollapsePaste(body)) {
+      showCollapsed(body);
+      return true;
+    }
+    original(body);
+    return true;
+  }
+
+  rl._ttyWrite = (s, key) => {
+    const str = s == null ? '' : String(s);
+
+    if (str.includes(BRACKETED_PASTE_START) || key?.name === 'paste-start') {
+      inPaste = true;
+      collecting = str.replace(BRACKETED_PASTE_START, '');
+      if (collecting.includes(BRACKETED_PASTE_END) || key?.name === 'paste-end') {
+        return consumePaste(collecting.replace(BRACKETED_PASTE_END, ''));
+      }
+      return undefined;
+    }
+    if (inPaste) {
+      collecting += str;
+      if (collecting.includes(BRACKETED_PASTE_END) || key?.name === 'paste-end') {
+        return consumePaste(collecting.replace(BRACKETED_PASTE_END, ''));
+      }
+      return undefined;
+    }
+
+    if (collapsed) {
+      if (key?.name === 'backspace' || key?.name === 'delete') {
+        collapsed = null;
+        refresh('');
+        return undefined;
+      }
+      if (key?.name === 'return' || key?.name === 'enter') {
+        const text = collapsed;
+        collapsed = null;
+        rl.line = text;
+        rl.cursor = text.length;
+        return original('\n', { name: 'return' });
+      }
+    }
+
+    if (str && !key?.name && shouldCollapsePaste(str.replace(/\n$/, ''))) {
+      const payload = str.endsWith('\n') ? str.slice(0, -1) : str;
+      showCollapsed(payload);
+      return undefined;
+    }
+
+    return original(s, key);
+  };
+
+  try { options.output?.write?.(BRACKETED_PASTE_ENABLE); } catch { /* ignore */ }
+  return () => {
+    rl._ttyWrite = original;
+    try { options.output?.write?.(BRACKETED_PASTE_DISABLE); } catch { /* ignore */ }
+  };
+}
+
+function resolveShellIdentity(state) {
+  if (state.identity && state.identityCwd === state.cwd) return state.identity;
+  try { state.identity = detectCliProject(state.cwd); }
+  catch { state.identity = { project: path.basename(state.cwd || ''), branch: '', root: state.cwd }; }
+  state.identityCwd = state.cwd;
+  return state.identity;
+}
+
+function renderShellSessionFooter(state) {
+  const identity = resolveShellIdentity(state);
+  const preferences = readCliPreferences(state.cwd) || {};
+  return renderCliFooter({
+    projectName: identity.project,
+    branch: identity.branch,
+    cwd: compactCwd(state.cwd),
+    model: state.session?.provider_model_id || state.session?.model_key || preferences.modelPreference,
+    provider: state.providerState?.provider || state.session?.provider_state?.provider,
+    effort: state.session?.reasoning_effort || preferences.reasoningEffort,
+    tier: state.session?.actual_service_tier || state.session?.requested_service_tier || preferences.serviceTier,
+    usageSnapshot: state.usageSnapshot || state.session?.usage_snapshot,
+    elapsedMs: state.lastTurnElapsedMs ?? (state.session ? localSessionElapsedMs(state.session) : undefined),
+    action: state.activity?.active ? 'working' : '',
+  });
+}
+
 export function tokenizeShellLine(input = '') {
   const source = String(input);
   const tokens = [];
@@ -121,9 +262,12 @@ function spawnGit(cwd, args) {
 function selectedModel(cwd) {
   const preferences = readCliPreferences(cwd) || {};
   const snapshot = preferences.modelSnapshot?.model_key === preferences.modelPreference
-    ? preferences.modelSnapshot
+    ? mergeModelReference(preferences.modelSnapshot)
     : null;
-  const model = snapshot || getModelRecord(preferences.modelPreference);
+  let model = snapshot || getModelRecord(preferences.modelPreference);
+  if (!model && (preferences.modelPreference === 'auto' || !preferences.modelPreference)) {
+    model = mergeModelReference(preferences.modelSnapshot) || listModelCatalog()[0];
+  }
   if (!model) throw new Error('Select an exact provider-verified model with /model first so Agent Sam can verify supported runtime controls.');
   return { preferences, model };
 }
@@ -169,24 +313,32 @@ async function resolveModelForTurn(cwd, state) {
 
 async function chooseReasoning(cwd, args, state) {
   const { preferences, model } = selectedModel(cwd);
+  const supported = ['auto', ...model.reasoning_efforts.filter((value) => value !== 'auto')];
   let effort = String(args[0] || '').trim().toLowerCase();
   if (!effort) {
     if (!state.interactive) {
-      writeLine(state.write, `  ${model.provider_model_id} reasoning: ${model.reasoning_efforts.join(' | ')}`);
-      writeLine(state.write, `  current: ${preferences.reasoningEffort || 'auto'}`);
+      writeLine(state.write, '  ' + model.provider_model_id + ' reasoning: ' + supported.join(' | '));
+      writeLine(state.write, '  provider default: ' + (model.default_reasoning_effort || 'unknown'));
+      writeLine(state.write, '  current: ' + (preferences.reasoningEffort || 'auto'));
       return;
     }
     const choice = await select({
-      message: `Reasoning level · ${model.provider_model_id}`,
-      initialValue: model.reasoning_efforts.includes(preferences.reasoningEffort) ? preferences.reasoningEffort : model.reasoning_efforts[0],
-      options: model.reasoning_efforts.map((value) => ({ value, label: value === 'xhigh' ? 'Extra high' : value === 'max' ? 'Max' : value[0].toUpperCase() + value.slice(1) })),
+      message: 'Reasoning level · ' + model.provider_model_id,
+      initialValue: supported.includes(preferences.reasoningEffort) ? preferences.reasoningEffort : 'auto',
+      options: supported.map((value) => ({
+        value,
+        label: value === 'auto' ? 'Automatic' : value === 'xhigh' ? 'Extra high' : value === 'max' ? 'Max' : value[0].toUpperCase() + value.slice(1),
+        hint: value === 'auto'
+          ? 'omit reasoning.effort · provider default ' + (model.default_reasoning_effort || 'unknown')
+          : value === model.default_reasoning_effort ? 'provider default' : undefined,
+      })),
     });
     if (isCancel(choice)) return;
     effort = choice;
   }
-  if (!model.reasoning_efforts.includes(effort)) throw new Error(`unsupported reasoning level for ${model.provider_model_id}: ${effort}`);
+  if (!supported.includes(effort)) throw new Error('unsupported reasoning level for ' + model.provider_model_id + ': ' + effort);
   updateCliPreferences(cwd, { reasoningEffort: effort });
-  writeLine(state.write, `  reasoning → ${effort}`);
+  writeLine(state.write, '  reasoning → ' + effort);
 }
 
 function setServiceTier(cwd, tier, write) {
@@ -241,15 +393,15 @@ export async function runLocalAgent(goal, write, options = {}) {
 }
 
 async function showLocalLogs(cwd, write) {
-  const dbPath = path.join(cwd, '.agentsam', 'data', 'agentsam.sqlite');
-  if (!fs.existsSync(dbPath)) { writeLine(write, '  No local Agent Sam DB found. Run `agentsam init . --yes` first.'); return; }
+  const dbPath = runtimeDatabasePath(cwd);
+  if (!fs.existsSync(dbPath)) { writeLine(write, '  No local Agent Sam runs yet.'); return; }
   const { createLocalSqliteDatabase } = await import('../local/sqlite.js');
   const db = await createLocalSqliteDatabase(dbPath);
   try {
-    const calls = await db.prepare('SELECT id, session_id, tool_name, status, created_at, completed_at FROM agent_tool_calls ORDER BY created_at DESC LIMIT 20').all();
-    if (!calls.results.length) { writeLine(write, '  No local Agent Sam tool-call events yet.'); return; }
-    writeLine(write, '\n  Recent Agent Sam tool calls');
-    for (const row of calls.results) writeLine(write, `  ${String(row.created_at || '').padEnd(20)} ${String(row.status || '').padEnd(10)} ${row.tool_name}`);
+    const runs = await db.prepare('SELECT id, model_key, status, started_at_unix FROM agentsam_agent_run ORDER BY started_at_unix DESC LIMIT 20').all();
+    if (!runs.results.length) { writeLine(write, '  No local Agent Sam runs yet.'); return; }
+    writeLine(write, '\n  Recent Agent Sam runs');
+    for (const row of runs.results) writeLine(write, `  ${new Date(Number(row.started_at_unix) * 1000).toISOString()} ${String(row.status || '').padEnd(10)} ${row.model_key || 'model unknown'} · ${row.id}`);
     writeLine(write, '');
   } finally { db.close(); }
 }
@@ -300,6 +452,7 @@ export function renderSessionReceipt(session) {
   if (componentTotal > 0) {
     lines.push(`Cost breakdown: input ${formatUsd(breakdown.input)} · cached ${formatUsd(breakdown.cached_input)} · cache write ${formatUsd(breakdown.cache_write)} · output ${formatUsd(breakdown.output)}`);
   }
+  if (session.latest_compaction) lines.push(`Latest compaction: ${session.latest_compaction.compaction_id || 'completed'} · ${formatUsd(session.latest_compaction.cost_usd)}`);
   if (active) lines.push(`Active context: ${formatCount(active)} tokens`);
   lines.push('', 'To continue this session, run:', `  agentsam resume ${session.id}`, '', 'Or run:', '  agentsam resume', '', 'and select:', `  ${session.title || 'this session'}`, '');
   return lines.join('\n');
@@ -307,7 +460,7 @@ export function renderSessionReceipt(session) {
 
 function persistSession(state, patch = {}) {
   if (!state.session) return null;
-  state.session = saveLocalSession({ ...state.session, ...patch }, { home: state.home });
+  state.session = saveLocalSession({ ...state.session, ...patch }, { home: state.home, projectRoot: state.projectRoot });
   return state.session;
 }
 
@@ -318,8 +471,6 @@ function recordSessionInput(state, input) {
   if (housekeeping.has(value.toLowerCase())) return;
   persistSession(state, {
     status: 'active',
-    last_input: value,
-    title: sessionTitleFromInput(value),
   });
 }
 
@@ -392,6 +543,55 @@ async function approveToolExecution(request, state) {
   return true;
 }
 
+async function runInteractiveCompaction(args, state) {
+  if (args.length > 1 || (args.length && args[0] !== 'status')) throw new Error('Usage: /compact [status]');
+  const { model } = selectedModel(state.cwd);
+  const supported = ['openai', 'grok'].includes(model.provider) && model.capabilities?.compaction === true;
+  const report = buildContextEconomicsReport(state.cwd, { activeInputTokens: state.usageSnapshot?.current_context?.input_tokens ?? state.session?.usage_snapshot?.current_context?.input_tokens });
+  if (args[0] === 'status') {
+    writeLine(state.write, `  Compaction · ${model.provider}/${model.provider_model_id}`);
+    writeLine(state.write, `  support       ${supported ? 'native' : 'unavailable'}`);
+    writeLine(state.write, `  active        ${report.active_input_tokens ?? 'unknown'} tokens`);
+    writeLine(state.write, `  threshold     ${report.compact_at_tokens ?? 'unknown'} tokens`);
+    writeLine(state.write, `  automatic     ${supported && state.session?.auto_compact !== false ? 'enabled' : 'disabled'}`);
+    const receipt = state.session?.latest_compaction;
+    writeLine(state.write, `  latest        ${receipt ? `${receipt.compaction_id} · ${receipt.created_at} · ${formatUsd(receipt.cost_usd)}` : 'none'}`);
+    return;
+  }
+  if (!supported) throw new Error(`native_compaction_unavailable:${model.provider}`);
+  if (!state.session || state.session.model_key !== model.model_key) throw new Error('compaction_active_model_session_required');
+  const previous = state.providerState || loadSessionContinuation(state.session);
+  if (!previous?.previous_response_id && !previous?.compacted_input?.length && !previous?.compaction_input?.length) throw new Error('compaction_context_unavailable');
+  const credential = resolveProviderCredential(model.provider, { home: state.home });
+  const provider = createProviderAdapter({ modelRecord: model, credential, fetchImpl: state.providerFetchImpl });
+  if (typeof provider.compact !== 'function') throw new Error(`native_compaction_unavailable:${model.provider}`);
+  const result = await provider.compact({
+    model: model.provider_model_id, modelRecord: model, providerState: previous,
+    promptCacheKey: state.session.id,
+    tokensBefore: report.active_input_tokens, cumulativeUsage: state.session.cumulative_usage,
+  });
+  if (!Array.isArray(result.output) || !result.output.length) throw new Error('provider_compaction_output_missing');
+  const receipt = checkpointCompaction(state, model, result);
+  writeLine(state.write, `  Compacted · ${receipt.compaction_id} · ${formatUsd(receipt.cost_usd)} · continuation saved`);
+}
+
+function checkpointCompaction(state, model, result) {
+  const delta = result.usage_delta || result.usage || {};
+  const cumulative = Object.fromEntries(['input_tokens', 'output_tokens', 'cached_input_tokens', 'cache_write_tokens', 'reasoning_tokens'].map(key => [key, Number(state.session.cumulative_usage?.[key] || 0) + Number(delta[key] || 0)]));
+  const providerState = { provider: model.provider, ...(result.provider_state || {}), previous_response_id: null, compacted_input: result.output };
+  const usageSnapshot = { current_context: { input_tokens: Math.ceil(JSON.stringify(result.output).length / 4), window_tokens: model.context_window }, cumulative, estimate_kind: 'local' };
+  const receipt = { compaction_id: result.compaction_id, provider: model.provider, model: model.provider_model_id, created_at: new Date().toISOString(), usage: delta, cost_usd: result.cost?.total_usd || 0 };
+  persistSession(state, {
+    provider_state: providerState, usage_snapshot: usageSnapshot, cumulative_usage: cumulative,
+    latest_compaction: receipt,
+    total_cost_usd: Number(state.session.total_cost_usd || 0) + Number(result.cost?.total_usd || 0),
+    cost_breakdown_usd: Object.fromEntries(['input', 'cached_input', 'cache_write', 'output'].map(key => [key, Number(state.session.cost_breakdown_usd?.[key] || 0) + Number(result.cost?.components_usd?.[key] || 0)])),
+  });
+  state.providerState = providerState;
+  state.usageSnapshot = usageSnapshot;
+  return receipt;
+}
+
 async function runInteractiveModelTurn(prompt, state) {
   const resolved = await resolveModelForTurn(state.cwd, state);
   const { preferences, model, credential } = resolved;
@@ -403,17 +603,15 @@ async function runInteractiveModelTurn(prompt, state) {
   });
   const capabilityAdapter = createCapabilityAdapter();
 
-  const samePolicy = state.session
-    && state.session.model_key === model.model_key
-    && state.session.reasoning_effort === preferences.reasoningEffort
-    && state.session.requested_service_tier === preferences.serviceTier;
-  const previousProviderState = samePolicy ? state.session?.provider_state : null;
+  // Reasoning/tier changes do not change the provider conversation's owner.
+  const samePolicy = state.session && state.session.model_key === model.model_key;
+  const previousProviderState = samePolicy ? (state.providerState || loadSessionContinuation(state.session)) : null;
   const previousUsageSnapshot = samePolicy ? state.session?.usage_snapshot : null;
   const accountId = readAccountSession({ home: state.home })?.account_id || null;
   let runtimeRunId = null;
   try {
     runtimeRunId = await startRuntimeRun({
-      cwd: state.cwd,
+      projectRoot: state.projectRoot,
       account_id: accountId,
       mode: 'agent',
       model_key: model.model_key,
@@ -431,6 +629,8 @@ async function runInteractiveModelTurn(prompt, state) {
   });
   state.activity = activity;
   const presenter = createCliRuntimePresenter({ activity, write: state.write, state });
+  const startingCostUsd = Number(state.session?.total_cost_usd || 0);
+  const startingCostBreakdown = { ...state.session?.cost_breakdown_usd };
   const startedAt = Date.now();
   activity.start(`Thinking · ${model.provider_model_id}`);
 
@@ -445,9 +645,17 @@ async function runInteractiveModelTurn(prompt, state) {
       modelRecord: model,
       reasoningEffort: preferences.reasoningEffort,
       serviceTier: preferences.serviceTier,
+      // The interactive CLI turn is the main agentic engineering loop, not a
+      // one-shot lookup -- the previous unconfigurable default (quick: 8
+      // rounds) killed genuine multi-step work for no reason tied to risk,
+      // cost, or progress. `agent` (128 rounds) is the right default here;
+      // preferences.runMode leaves room for a future explicit override.
+      runMode: preferences.runMode || 'agent',
       previousProviderState,
       previousUsageSnapshot,
       cumulativeUsage: state.session?.cumulative_usage || null,
+      autoCompact: state.session?.auto_compact !== false,
+      onCompaction: result => { if (state.session) checkpointCompaction(state, model, result); },
       promptCacheKey: state.session?.id || undefined,
       runId: runtimeRunId || state.session?.id || undefined,
       beforeRequest: (preflight) => approveModelRequest(preflight, state),
@@ -463,7 +671,7 @@ async function runInteractiveModelTurn(prompt, state) {
     if (runtimeRunId) {
       try {
         await finishRuntimeRun({
-          cwd: state.cwd,
+          projectRoot: state.projectRoot,
           id: runtimeRunId,
           status: 'failed',
           error_code: error?.code || 'interactive_error',
@@ -488,10 +696,12 @@ async function runInteractiveModelTurn(prompt, state) {
   }
 
   state.usageSnapshot = result.usage_snapshot;
+  state.providerState = result.provider_state || null;
+  state.lastTurnElapsedMs = Date.now() - startedAt;
   if (runtimeRunId) {
     try {
       await finishRuntimeRun({
-        cwd: state.cwd,
+        projectRoot: state.projectRoot,
         id: runtimeRunId,
         status: 'completed',
         actual_service_tier: result.actual_service_tier,
@@ -501,7 +711,7 @@ async function runInteractiveModelTurn(prompt, state) {
       });
       if (presenter.state.lastCompaction) {
         await recordRuntimeCompaction({
-          cwd: state.cwd,
+          projectRoot: state.projectRoot,
           account_id: accountId,
           agent_run_id: runtimeRunId,
           session_id: state.session?.id,
@@ -527,30 +737,66 @@ async function runInteractiveModelTurn(prompt, state) {
       provider_state: { provider: model.provider, ...(result.provider_state || {}) },
       usage_snapshot: result.usage_snapshot,
       cumulative_usage: result.cumulative_usage,
-      total_cost_usd: Number(state.session.total_cost_usd || 0) + Number(result.total_cost_usd || 0),
+      latest_compaction: result.compaction || state.session.latest_compaction,
+      total_cost_usd: startingCostUsd + Number(result.total_cost_usd || 0),
       cost_breakdown_usd: Object.fromEntries(['input', 'cached_input', 'cache_write', 'output'].map((key) => [
-        key, Number(state.session.cost_breakdown_usd?.[key] || 0) + Number(result.cost_breakdown_usd?.[key] || 0),
+        key, Number(startingCostBreakdown[key] || 0) + Number(result.cost_breakdown_usd?.[key] || 0),
       ])),
       last_error: null,
     });
   }
 
+  const identity = resolveShellIdentity(state);
   writeLine(state.write, renderCliFooter({
+    projectName: identity.project,
+    branch: identity.branch,
+    cwd: compactCwd(state.cwd),
     model: result.model || model.provider_model_id,
+    provider: model.provider,
+    effort: result.reasoning_effort,
     usageSnapshot: result.usage_snapshot,
     tier: result.actual_service_tier,
-    elapsedMs: Date.now() - startedAt,
+    elapsedMs: state.lastTurnElapsedMs,
   }));
   writeLine(state.write, '');
+  state.wroteTurnFooter = true;
   return result;
 }
 
 export async function dispatchShellLine(line, state = {}) {
-  const tokens = tokenizeShellLine(line);
+  let tokens = tokenizeShellLine(line);
   const write = state.write || ((text) => process.stdout.write(text));
   state.write = write;
   state.cwd = path.resolve(state.cwd || process.cwd());
+  state.projectRoot ||= findCliProjectRoot(state.cwd);
   if (!tokens.length) return { handled: true, exit: false, cwd: state.cwd };
+
+  // Strip a leading "agentsam" prefix if present -- it should never change
+  // whether the rest of the line resolves, only whether it was typed at all.
+  if (tokens[0].toLowerCase() === 'agentsam') {
+    tokens = tokens.slice(1);
+    if (!tokens.length) tokens = ['help'];
+  }
+
+  // Recognized short verbs (with or without a stripped "agentsam" prefix)
+  // become their slash command. Anything unrecognized -- typo, a host-CLI-only
+  // verb like "merkle" typed here, whatever -- is left as plain text and
+  // falls through to the natural-language model turn below. There is no
+  // path left that hard-errors on an unrecognized word; "unknown command"
+  // only fires for input that explicitly starts with "/".
+  if (!tokens[0].startsWith('/')) {
+    const bare = tokens[0].toLowerCase();
+    const commonVerbs = [
+      'help', 'exit', 'quit', 'clear', 'status', 'models', 'model',
+      'whoami', 'cf', 'cloudflare', 'db', 'tunnel', 'connections',
+      'connect', 'usage', 'session', 'providers', 'settings', 'logs',
+      'git', 'diff', 'pwd', 'cd', 'fast', 'flex', 'standard', 'reasoning',
+    ];
+    if (commonVerbs.includes(bare)) {
+      tokens[0] = `/${bare}`;
+    }
+  }
+
   const [command, ...args] = tokens;
   try {
     switch (command.toLowerCase()) {
@@ -565,8 +811,15 @@ export async function dispatchShellLine(line, state = {}) {
       case '/quit':
         return { handled: true, exit: true, cwd: state.cwd };
       case '/model': {
-        const configured = await configureCliPreferences({ cwd: state.cwd, firstRun: false, section: 'model', home: state.home });
-        state.cwd = configured.identity.root;
+        state.rl?.pause?.();
+        try {
+          const configured = await configureCliPreferences({ cwd: state.cwd, firstRun: false, section: 'model', home: state.home });
+          state.cwd = configured.identity.root;
+          state.projectRoot = findCliProjectRoot(state.cwd);
+        } finally {
+          if (process.stdin.isPaused()) process.stdin.resume();
+          state.rl?.resume?.();
+        }
         break;
       }
       case '/reasoning':
@@ -581,21 +834,37 @@ export async function dispatchShellLine(line, state = {}) {
       case '/standard':
         setServiceTier(state.cwd, 'default', write);
         break;
+      case '/compact':
+        await runInteractiveCompaction(args, state);
+        break;
       case '/context':
         if (args[0] === 'repo' || args[0] === 'git') await runContext(['--cwd', state.cwd, ...args.slice(1)]);
         else write(renderContextEconomics(buildContextEconomicsReport(state.cwd, {
           activeInputTokens: state.usageSnapshot?.current_context?.input_tokens,
           estimateKind: state.usageSnapshot?.estimate_kind,
+          autoCompact: state.session?.auto_compact,
         })));
         break;
       case '/status':
         await runStatus(args, { cwd: state.cwd });
         break;
       case '/models':
-        await runModels(args, { cwd: state.cwd, write, home: state.home });
+        state.rl?.pause?.();
+        try {
+          await runModels(args, { cwd: state.cwd, write, home: state.home, interactive: state.interactive });
+        } finally {
+          if (process.stdin.isPaused()) process.stdin.resume();
+          state.rl?.resume?.();
+        }
         break;
       case '/providers':
-        await runProviders(args, { write, home: state.home, interactive: state.interactive });
+        state.rl?.pause?.();
+        try {
+          await runProviders(args, { write, home: state.home, interactive: state.interactive });
+        } finally {
+          if (process.stdin.isPaused()) process.stdin.resume();
+          state.rl?.resume?.();
+        }
         break;
       case '/login':
         await runLogin(args, { write, home: state.home });
@@ -608,17 +877,43 @@ export async function dispatchShellLine(line, state = {}) {
         await runWhoami(args, { write, home: state.home });
         break;
       case '/session':
-      case '/usage':
         if (state.session) write(renderSessionReceipt(state.session));
         else writeLine(write, '  No persistent session is active in this shell invocation.');
         break;
+      case '/usage':
+        write(renderUsagePanel({
+          session: state.session,
+          usage: state.usageSnapshot || state.session?.usage_snapshot,
+          provider: state.providerState?.provider || state.session?.provider,
+          model: state.providerState?.model || state.session?.model,
+          effort: state.providerState?.reasoning_effort || state.session?.reasoning_effort,
+          tier: state.providerState?.service_tier || state.session?.service_tier,
+          estimateKind: state.usageSnapshot?.estimate_kind,
+          elapsedMs: state.session ? localSessionElapsedMs(state.session) : null,
+          cost: state.usageSnapshot?.cumulative?.cost_usd ?? state.session?.cumulative_usage?.cost_usd,
+        }));
+        break;
       case '/cf':
       case '/cloudflare':
         await runCloudflare(args.length ? args : ['commands'], { cwd: state.cwd, write });
         break;
+      case '/connections':
+      case '/connect':
+        await runConnections(args, { cwd: state.cwd, write, home: state.home });
+        break;
+      case '/tunnel':
+        await runTunnel(args, { cwd: state.cwd, write, home: state.home, interactive: state.interactive });
+        break;
       case '/settings': {
-        const configured = await configureCliPreferences({ cwd: state.cwd, firstRun: false, home: state.home });
-        state.cwd = configured.identity.root;
+        state.rl?.pause?.();
+        try {
+          const configured = await configureCliPreferences({ cwd: state.cwd, firstRun: false, home: state.home });
+          state.cwd = configured.identity.root;
+          state.projectRoot = findCliProjectRoot(state.cwd);
+        } finally {
+          if (process.stdin.isPaused()) process.stdin.resume();
+          state.rl?.resume?.();
+        }
         break;
       }
       case '/pwd':
@@ -628,22 +923,100 @@ export async function dispatchShellLine(line, state = {}) {
         const destination = args.length ? args.join(' ') : process.env.HOME || process.env.USERPROFILE || state.cwd;
         const next = path.resolve(state.cwd, destination);
         if (!fs.existsSync(next) || !fs.statSync(next).isDirectory()) throw new Error(`directory not found: ${next}`);
+        const nextRoot = findCliProjectRoot(next);
+        if (nextRoot !== (state.projectRoot || findCliProjectRoot(state.cwd))) {
+          if (state.session) {
+            persistSession(state, { status: 'paused', active_elapsed_ms: localSessionElapsedMs(state.session), active_started_at: null });
+            state.session = createLocalSession({ cwd: next, project_root: nextRoot }, { projectRoot: nextRoot, home: state.home });
+          }
+          state.projectRoot = nextRoot;
+          state.usageSnapshot = null;
+          state.providerState = null;
+        }
         state.cwd = next;
+        state.identity = null;
+        state.identityCwd = null;
         writeLine(write, state.cwd);
         break;
       }
       case '/git':
         spawnGit(state.cwd, args.length ? args : ['status', '--short', '--branch']);
         break;
-      case '/diff':
-        spawnGit(state.cwd, ['diff', ...args]);
+      case '/diff': {
+        const result = spawnSync('git', ['diff', '--no-color', ...args], { cwd: state.cwd, encoding: 'utf8', shell: false });
+        if (result.error) throw result.error;
+        if (result.status !== 0 && !String(result.stdout || '').trim()) {
+          throw new Error(String(result.stderr || `git exited ${result.status}`).trim());
+        }
+        write(renderDiffPreview(result.stdout || ''));
         break;
+      }
       case '/db':
-        await runDb(args.length ? args : ['status'], { cwd: state.cwd });
+        await runDb(args.length ? args : ['status'], { cwd: state.projectRoot || state.cwd, write });
         break;
       case '/agent':
         await runLocalAgent(args.join(' '), write, { interactive: state.interactive });
         break;
+      case '/goap': {
+        const sub = (args[0] || 'status').toLowerCase();
+        if (sub === 'list' || sub === 'ls') {
+          const listState = await listGoapTickets({ cwd: state.cwd });
+          if (!listState.ok) {
+            writeLine(write, `  Failed to list GOAP tickets: ${listState.error || 'unknown error'}`);
+          } else {
+            writeLine(write, renderGoapList(listState));
+          }
+          break;
+        }
+        if (sub === 'new' || sub === 'create') {
+          const title = args.slice(1).join(' ').trim();
+          if (!title) {
+            writeLine(write, '  Usage: /goap new <title>');
+            break;
+          }
+          const res = await createGoapGoal({ cwd: state.cwd, title, accountId: readAccountSession({ home: state.home })?.account_id || null });
+          if (!res.ok) {
+            writeLine(write, `  Failed to create GOAP goal: ${res.error || 'unknown error'}`);
+          } else {
+            writeLine(write, `  Created and activated goal: ${res.ticketId} ("${res.title}")`);
+          }
+          break;
+        }
+        if (sub === 'switch' || sub === 'select') {
+          const tid = args[1]?.trim();
+          if (!tid) {
+            writeLine(write, '  Usage: /goap switch <ticket_id>');
+            break;
+          }
+          const res = await switchGoapGoal({ cwd: state.cwd, ticketId: tid, accountId: readAccountSession({ home: state.home })?.account_id || null });
+          if (!res.ok) {
+            writeLine(write, `  Failed to switch GOAP goal: ${res.error || 'unknown error'}`);
+          } else {
+            writeLine(write, `  Switched active GOAP goal to: ${res.ticketId}`);
+          }
+          break;
+        }
+        if (sub === 'close') {
+          const tid = args[1]?.trim() || null;
+          const res = await closeGoapGoal({ cwd: state.cwd, ticketId: tid, accountId: readAccountSession({ home: state.home })?.account_id || null });
+          if (!res.ok) {
+            writeLine(write, `  Failed to close GOAP goal: ${res.error || 'unknown error'}`);
+          } else {
+            writeLine(write, `  Closed GOAP goal: ${res.ticketId} [${res.status}]`);
+          }
+          break;
+        }
+        const goapState = await readGoapState({ cwd: state.cwd, accountId: readAccountSession({ home: state.home })?.account_id || null });
+        if (!goapState.ok) {
+          writeLine(write, `  Failed to read GOAP state: ${goapState.error || 'unknown error'}`);
+          break;
+        }
+        if (sub === 'goal') writeLine(write, renderGoapGoal(goapState));
+        else if (sub === 'why') writeLine(write, renderGoapWhy(goapState));
+        else if (sub === 'plan') writeLine(write, renderGoapPlan(goapState));
+        else writeLine(write, renderGoapStatus(goapState));
+        break;
+      }
       case '/logs':
         await showLocalLogs(state.cwd, write);
         break;
@@ -658,8 +1031,44 @@ export async function dispatchShellLine(line, state = {}) {
           await runInteractiveModelTurn(line, state);
           break;
         }
+        {
+          // Explicit slash → portable skill registry (no D1 / R2 / subagents).
+          const skillRuntime = new SkillRuntime({
+            registry: new SkillRegistry({ home: state.home }),
+            contentResolver: new SkillContentResolver(),
+          });
+          const skillResult = await skillRuntime.invoke({ input: line });
+          if (skillResult.matched) {
+            const interactiveStatuses = new Set(['needs_input', 'needs_approval', 'blocked']);
+            if (
+              state.interactive &&
+              interactiveStatuses.has(skillResult.interaction?.status) &&
+              skillResult.interaction?.prompt
+            ) {
+              const choice = await presentAgentSamInteraction(skillResult.interaction, {
+                write,
+                interactive: state.interactive,
+              });
+              if (choice.action === 'create' || String(choice.value || '').startsWith('create')) {
+                await handleSkillInteractionChoice(choice, { write, home: state.home });
+              } else if (choice.action === 'list' || choice.value === 'list') {
+                await handleSkillInteractionChoice(choice, { write, home: state.home });
+              } else if (choice.action === 'install' || choice.value === 'install') {
+                await handleSkillInteractionChoice(choice, { write, home: state.home });
+              }
+            } else if (skillResult.interaction?.prompt?.message) {
+              for (const msgLine of String(skillResult.interaction.prompt.message).split('\n')) {
+                writeLine(write, `  ${msgLine}`);
+              }
+            } else if (skillResult.modelInstructions?.content) {
+              writeLine(write, `  skill ${skillResult.skill?.id} · ${skillResult.receipt?.checksum || 'resolved'}`);
+              writeLine(write, `  (turn instructions ready · ${skillResult.tools?.length || 0} tools declared)`);
+            }
+            break;
+          }
+        }
         writeLine(write, `  Unknown Agent Sam command: ${command}`);
-        writeLine(write, '  Type / or /help for available commands.');
+        writeLine(write, '  Type / or /help for available commands. Use /skills for installable slash skills.');
         return { handled: false, exit: false, cwd: state.cwd };
     }
   } catch (error) {
@@ -667,9 +1076,15 @@ export async function dispatchShellLine(line, state = {}) {
       persistSession(state, { last_error: diagnosticFromError(error, { source: 'shell', kind: 'interactive_error' }) });
     }
     if (!error?.reported) {
-      for (const line of renderDiagnosticError(error).split('\n')) writeLine(write, `  ${line}`);
+      for (const errorLine of renderDiagnosticError(error).split('\n')) writeLine(write, `  ${errorLine}`);
     }
   }
+  const skipFooter = state.wroteTurnFooter;
+  state.wroteTurnFooter = false;
+  if (state.persistFooter && !skipFooter) {
+    writeLine(write, renderShellSessionFooter(state));
+    writeLine(write, '');
+  }
   return { handled: true, exit: false, cwd: state.cwd };
 }
 
@@ -677,14 +1092,18 @@ export async function runShell(argv = [], options = {}) {
   const write = options.write || ((text) => process.stdout.write(text));
   const state = {
     cwd: path.resolve(options.cwd || process.cwd()),
+    projectRoot: findCliProjectRoot(options.session?.project_root || options.cwd || process.cwd()),
     write,
     interactive: options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY),
     usageSnapshot: options.usageSnapshot || options.session?.usage_snapshot || null,
+    providerState: null,
     session: options.session || null,
     home: options.home,
     providerFetchImpl: options.providerFetchImpl,
+    persistFooter: options.persistFooter === true,
   };
   const sub = argv[0] || '';
+  hydrateSecureCredentials(process.env, { home: state.home });
   if (sub === 'list' || sub === 'status') { write(renderShellCatalog()); return; }
   if (sub === '--command' || sub === '--once') {
     const line = argv.slice(1).join(' ');
@@ -701,40 +1120,73 @@ export async function runShell(argv = [], options = {}) {
       status: 'active',
       cwd: state.cwd,
       active_started_at: new Date().toISOString(),
-    }, { home: state.home });
+    }, { home: state.home, projectRoot: state.projectRoot });
     state.usageSnapshot = state.session.usage_snapshot || state.usageSnapshot;
   } else {
     const preferences = readCliPreferences(state.cwd) || {};
     state.session = createLocalSession({
       cwd: state.cwd,
+      project_root: state.projectRoot,
       status: 'active',
       model_key: preferences.modelPreference !== 'auto' ? preferences.modelPreference : null,
       reasoning_effort: preferences.reasoningEffort !== 'auto' ? preferences.reasoningEffort : null,
       requested_service_tier: preferences.serviceTier || 'default',
-    }, { home: state.home });
+    }, { home: state.home, projectRoot: state.projectRoot });
   }
 
   if (options.intro !== 'quiet') {
     write(renderShellCatalog());
     writeLine(write, '  Interactive shell ready. Type / for the command picker; /exit to return to your host shell.\n');
   }
+  state.persistFooter = options.persistFooter !== false;
+  writeLine(write, renderShellSessionFooter(state));
+  writeLine(write, '');
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: Boolean(process.stdin.isTTY && process.stdout.isTTY) });
+  state.rl = rl;
+  let promptTextRef = () => renderShellPrompt(state.cwd);
+  const restorePaste = installPasteCollapse(rl, { output: process.stdout });
   let interrupted = false;
+  let lastSigintAt = 0;
+  const SIGINT_EXIT_WINDOW_MS = 2000;
   rl.on('SIGINT', () => {
-    interrupted = true;
-    rl.close();
+    const now = Date.now();
+    if (now - lastSigintAt < SIGINT_EXIT_WINDOW_MS) {
+      // Second Ctrl+C within the window: actually exit, matching the
+      // near-universal CLI convention (bash, node REPL, Claude Code, Codex).
+      interrupted = true;
+      rl.close();
+      return;
+    }
+    // First Ctrl+C: cancel the current line/prompt only, matching what the
+    // footer already tells the user ("ctrl-c to cancel"). A single press
+    // used to close the whole session outright -- that's the discrepancy
+    // being fixed here, not the intended behavior.
+    lastSigintAt = now;
+    write('\n  (Ctrl+C again within 2s to exit)\n');
+    rl.line = '';
+    rl.cursor = 0;
+    if (rl.terminal) { rl.setPrompt(promptTextRef()); rl.prompt(); }
   });
   const promptText = () => {
     if (typeof options.prompt === 'function') return options.prompt(state);
     if (typeof options.prompt === 'string' && options.prompt) return options.prompt;
     return renderShellPrompt(state.cwd);
   };
-  if (rl.terminal) { rl.setPrompt(promptText()); rl.prompt(); }
-  for await (const line of rl) {
-    recordSessionInput(state, line);
-    const result = await dispatchShellLine(line, state);
-    if (result.exit) { rl.close(); break; }
+  promptTextRef = promptText;
+  try {
     if (rl.terminal) { rl.setPrompt(promptText()); rl.prompt(); }
+    for await (const line of rl) {
+      recordSessionInput(state, line);
+      const result = await dispatchShellLine(line, state);
+      if (result.exit) { rl.close(); break; }
+      if (process.stdin.isPaused()) {
+        process.stdin.resume();
+      }
+      if (rl.terminal) { rl.setPrompt(promptText()); rl.prompt(); }
+    }
+  } finally {
+    restorePaste();
+    state.rl = null;
   }
   if (state.session) {
     const activeElapsedMs = localSessionElapsedMs(state.session);