@milpa/comal 0.1.7 → 0.2.1

package/src/codex-provider.mjs

@@ -202,13 +202,14 @@ export class CodexProvider {
       if (framed.format === 'json') {
         const result = normalized(await responseJSON(framed.body)); for (const block of result.content) if (block.type === 'text') onText(block.text); return account(result);
       }
-      let result, textChars = 0, reasoningChars = 0, argumentChars = 0;
+      let result, textChars = 0, reasoningChars = 0, argumentChars = 0, toolName;
       for await (const event of sseEvents(framed.body)) {
         if (event.type === 'response.output_text.delta') { onText(event.delta || ''); textChars += (event.delta || '').length; deadline.touch(); }
         else if (event.type === 'response.reasoning_summary_text.delta') { reasoningChars += (event.delta || '').length; deadline.touch(); }
         else if (event.type === 'response.function_call_arguments.delta') { argumentChars += (event.delta || '').length; deadline.touch(); }
+        else if (event.type === 'response.output_item.added') { toolName = event.item?.type === 'function_call' && typeof event.item.name === 'string' ? event.item.name : undefined; }
         else if (event.type === 'response.completed') result = normalized(event.response);
-        else if (['response.failed', 'response.incomplete', 'error'].includes(event.type)) throw responseFailure(event);
+        else if (['response.failed', 'response.incomplete', 'error'].includes(event.type)) { const failure = responseFailure(event); if (failure.code === 'OUTPUT_LENGTH') failure.details = { ...failure.details, text_chars: textChars, reasoning_chars: reasoningChars, tool_argument_chars: argumentChars, ...(toolName ? { tool_name: toolName } : {}) }; throw failure; }
         onProgress({ text_chars: textChars, reasoning_chars: reasoningChars, tool_argument_chars: argumentChars, elapsed_ms: deadline.elapsedMs(), purpose });
       }
       deadline.signal.throwIfAborted();

package/src/connection-settings.mjs

@@ -0,0 +1,204 @@
+import { t, registerMessages } from './i18n/index.mjs';
+import { contextSettings, resolveContextBudget } from './compaction.mjs';
+import { comalEnvironment } from './compat.mjs';
+import { AUTH_PROVIDERS } from './provider-auth.mjs';
+import { connectionPreferenceFile, saveConnection, saveLimits } from './onboarding.mjs';
+
+// Configuración de la conexión desde dentro de la sesión: /max-tokens,
+// /context-window y /config. Sólo lee estados y nombres de variables; nunca
+// toca una llave. cli.mjs sólo cablea getters y efectos.
+registerMessages({
+  'Use /max-tokens [N] with N between 64 and 1000000.': 'Usa /max-tokens [N] con N entre 64 y 1000000.',
+  'Use /context-window [auto|N] with N between 4096 and 2000000.': 'Usa /context-window [auto|N] con N entre 4096 y 2000000.',
+  'The effective window ({window}) must be at least twice max-tokens ({maxTokens}, the output reserve). Lower /max-tokens or raise /context-window; nothing was changed.': 'La ventana efectiva ({window}) debe ser al menos el doble de max-tokens ({maxTokens}, la reserva de salida). Baja /max-tokens o sube /context-window; no se cambió nada.',
+  'Max tokens: {value} · source {source}': 'Max-tokens: {value} · origen {source}',
+  'Context window: {value} · {kind} · source {source} · announced {announced} · explicit limit {limit}': 'Ventana de contexto: {value} · {kind} · origen {source} · anunciada {announced} · límite explícito {limit}',
+  'Applied to this session.': 'Aplicado a esta sesión.',
+  'Saved in {file} for the next sessions.': 'Guardado en {file} para las siguientes sesiones.',
+  'Applied, but not saved: {reason}': 'Aplicado, pero no se guardó: {reason}',
+  'The startup flag {flag} still wins over the saved value when it is passed.': 'La bandera de arranque {flag} sigue mandando sobre lo guardado cuando se pasa.',
+  'The environment variable {name} still wins over the saved value.': 'La variable de entorno {name} sigue mandando sobre lo guardado.',
+  'Saved limits were ignored: {reason}': 'Se ignoraron los límites guardados: {reason}',
+  'Use /config, /config set KEY VALUE or /config save. Keys: {keys}.': 'Usa /config, /config set CLAVE VALOR o /config save. Claves: {keys}.',
+  'The demo has no connection to save.': 'La demo no tiene conexión que guardar.',
+  'Profiles are selected with defaultProfile in {file}; nothing was saved.': 'Los perfiles se eligen con defaultProfile en {file}; no se guardó nada.',
+  'Default connection saved in {file}: {summary}. Startup flags still win.': 'Conexión por omisión guardada en {file}: {summary}. Las banderas de arranque siguen mandando.',
+  'Comal configuration': 'Configuración de Comal',
+  'Provider': 'Proveedor', 'Login': 'Login', 'Credential': 'Credencial', 'Model': 'Modelo', 'Effort': 'Effort', 'Context window': 'Ventana',
+  'Max tokens': 'Max-tokens', 'Permissions': 'Permisos', 'Plugins': 'Plugins', 'Files': 'Archivos',
+  'connection': 'conexión', 'credentials': 'credenciales', 'profiles': 'perfiles', 'plugins': 'plugins',
+  'none': 'ninguno', 'unknown': 'desconocida', 'demo without provider': 'demo sin proveedor',
+  'no login · key from {name} ({state})': 'sin login · llave de {name} ({state})', 'defined': 'definida', 'not defined': 'no definida',
+  'no credential': 'sin credencial', 'method {method}': 'método {method}', 'expires {date}': 'expira {date}', 'stored key, does not expire': 'llave guardada, no expira',
+  'connected': 'conectado', 'configured': 'configurado', 'expired': 'expirado', 'logged out': 'sin sesión',
+  'active: {list}': 'activos: {list}', 'inactive: {list}': 'inactivos: {list}', 'unavailable': 'no disponible',
+  'Change: /config set model|effort|provider|permissions|max-tokens|context-window VALUE · /config save remembers this connection · /login PROVIDER': 'Cambiar: /config set model|effort|provider|permissions|max-tokens|context-window VALOR · /config save recuerda esta conexión · /login PROVEEDOR',
+  'session': 'sesión', 'flag': 'bandera', 'environment': 'entorno', 'saved': 'guardado', 'default': 'omisión',
+  'detected': 'detectada', 'announced {value}': 'anunciada {value}', 'configured limit': 'límite configurado', 'fallback': 'por omisión',
+});
+
+const MIN_OUTPUT = 64, MAX_OUTPUT = 1000000, MIN_WINDOW = 4096, MAX_WINDOW = 2000000;
+const FALLBACK_WINDOW = contextSettings({}, {}).contextWindow;
+const SOURCE_LABELS = { session: 'session', cli: 'flag', environment: 'environment', saved: 'saved', fallback: 'default', default: 'default' };
+const sourceLabel = value => t(SOURCE_LABELS[value] || value || 'unknown');
+const integer = text => /^\d{1,9}$/.test(text) ? Number(text) : NaN;
+
+export function parseLimit(key, text) {
+  const value = String(text ?? '').trim().replace(/[_,]/g, '');
+  if (key === 'max-tokens') {
+    const n = integer(value);
+    if (!Number.isSafeInteger(n) || n < MIN_OUTPUT || n > MAX_OUTPUT) throw new Error(t('Use /max-tokens [N] with N between 64 and 1000000.'));
+    return n;
+  }
+  if (key === 'context-window') {
+    if (value.toLowerCase() === 'auto') return 'auto';
+    const n = integer(value);
+    if (!Number.isSafeInteger(n) || n < MIN_WINDOW || n > MAX_WINDOW) throw new Error(t('Use /context-window [auto|N] with N between 4096 and 2000000.'));
+    return n;
+  }
+  throw new TypeError('Unknown limit.');
+}
+
+/**
+ * Precedencia al arrancar: bandera > variable de entorno > connection.json >
+ * omisión. Si lo guardado no encaja con una bandera, se ignora con aviso en vez
+ * de impedir el arranque.
+ */
+export function resolveStartupLimits({ flags = {}, saved = {}, env = process.env } = {}) {
+  const environment = comalEnvironment(env), warnings = [];
+  const fromSaved = { maxTokens: flags.maxTokens == null && environment.COMAL_MAX_TOKENS == null && Number.isSafeInteger(saved['max-tokens']),
+    contextWindow: flags.contextWindow == null && environment.COMAL_CONTEXT_WINDOW == null && Number.isSafeInteger(saved['context-window']) };
+  const build = useSaved => {
+    const config = contextSettings({ contextWindow: flags.contextWindow ?? (useSaved && fromSaved.contextWindow ? saved['context-window'] : undefined),
+      maxTokens: flags.maxTokens ?? (useSaved && fromSaved.maxTokens ? saved['max-tokens'] : undefined) }, env);
+    if (useSaved && fromSaved.contextWindow) config.contextWindowSource = 'saved';
+    config.maxTokensSource = flags.maxTokens != null ? 'cli' : environment.COMAL_MAX_TOKENS != null ? 'environment' : useSaved && fromSaved.maxTokens ? 'saved' : 'default';
+    return config;
+  };
+  if (!fromSaved.maxTokens && !fromSaved.contextWindow) return { config: build(false), warnings };
+  try { return { config: build(true), warnings }; }
+  catch (error) { warnings.push(t('Saved limits were ignored: {reason}', { reason: error.message })); return { config: build(false), warnings }; }
+}
+
+/** Calcula los límites candidatos sin aplicarlos. */
+export function nextLimits(current, key, value) {
+  if (key === 'max-tokens') return { ...current, maxTokens: value, maxTokensSource: 'session' };
+  return value === 'auto' ? { ...current, contextWindow: FALLBACK_WINDOW, contextWindowSource: 'fallback' }
+    : { ...current, contextWindow: value, contextWindowSource: 'session' };
+}
+
+/** Regla de resolveContextBudget con un error que dice qué hacer. */
+export function checkLimits(candidate, report) {
+  try { return resolveContextBudget(candidate, report); }
+  catch (error) {
+    let window;
+    try { window = resolveContextBudget({ ...candidate, maxTokens: 0 }, report).contextWindow; } catch { throw error; }
+    if (window >= candidate.maxTokens * 2) throw error;
+    throw Object.assign(new Error(t('The effective window ({window}) must be at least twice max-tokens ({maxTokens}, the output reserve). Lower /max-tokens or raise /context-window; nothing was changed.', { window, maxTokens: candidate.maxTokens })), { code: 'CONTEXT_LIMITS_INVALID' });
+  }
+}
+
+const SET_KEYS = ['model', 'effort', 'provider', 'permissions', 'max-tokens', 'context-window'];
+export function parseConfigCommand(arg) {
+  const parts = String(arg || '').trim().split(/\s+/).filter(Boolean);
+  if (!parts.length || parts.length === 1 && ['show', 'status'].includes(parts[0])) return { action: 'show' };
+  if (parts.length === 1 && parts[0] === 'save') return { action: 'save' };
+  const key = parts[1] === 'mode' ? 'permissions' : parts[1];
+  if (parts[0] === 'set' && parts.length === 3 && SET_KEYS.includes(key)) return { action: 'set', key, value: parts[2] };
+  throw new Error(t('Use /config, /config set KEY VALUE or /config save. Keys: {keys}.', { keys: SET_KEYS.join(', ') }));
+}
+
+function loginLine(state, status) {
+  if (!status) return t('no credential');
+  const words = { authenticated: 'connected', configured: 'configured', expired: 'expired', logged_out: 'logged out' };
+  return [t(words[status.status] || 'unknown'), t('method {method}', { method: status.method }),
+    status.expiresAt ? t('expires {date}', { date: new Date(status.expiresAt).toISOString() }) : status.status === 'configured' ? t('stored key, does not expire') : ''].filter(Boolean).join(' · ');
+}
+function pluginLine(status) {
+  if (!status || !Array.isArray(status.plugins)) return t('unavailable');
+  const active = status.plugins.filter(item => item.state === 'active'), other = status.plugins.filter(item => item.state !== 'active');
+  return [t('active: {list}', { list: active.map(item => item.id).join(', ') || t('none') }),
+    other.length ? t('inactive: {list}', { list: other.map(item => `${item.id} (${item.state})`).join(', ') }) : ''].filter(Boolean).join(' · ');
+}
+
+/** Texto de /config. Recibe sólo datos de estado: nunca la llave ni el proveedor vivo. */
+export function formatConfig(view) {
+  const row = (label, value) => `${(t(label) + ':').padEnd(16)} ${value}`.trimEnd();
+  const budget = view.budget || {};
+  const kinds = { detected: 'detected', configured: 'configured limit', fallback: 'fallback' };
+  const lines = [t('Comal configuration'), '',
+    row('Provider', view.demo ? t('demo without provider') : [view.provider, view.authProvider ? `login ${view.authProvider}` : view.profile ? `profile ${view.profile}` : '', view.endpoint].filter(Boolean).join(' · ')),
+    view.authProvider ? row('Login', loginLine(view, view.login)) : row('Credential', view.demo ? t('none') : t('no login · key from {name} ({state})', { name: view.apiKeyEnv || 'OPENAI_API_KEY', state: t(view.apiKeyDefined ? 'defined' : 'not defined') })),
+    row('Model', view.model || t('unknown')),
+    row('Effort', `${view.effort || 'auto'}${view.thinking ? ` · thinking ${view.thinking}` : ''}`),
+    row('Context window', [budget.contextWindow ?? view.limits.contextWindow, t(kinds[budget.kind] || 'unknown'), `${sourceLabel(budget.source)}`, budget.announcedWindow && budget.announcedWindow !== budget.contextWindow ? t('announced {value}', { value: budget.announcedWindow }) : ''].filter(Boolean).join(' · ')),
+    row('Max tokens', `${view.limits.maxTokens} · ${sourceLabel(view.limits.maxTokensSource)}`),
+    row('Permissions', view.mode),
+    row('Plugins', pluginLine(view.plugins)),
+    row('Files', ''),
+    ...view.paths.map(([label, file]) => `  ${t(label).padEnd(14)} ${file}`),
+    '', t('Change: /config set model|effort|provider|permissions|max-tokens|context-window VALUE · /config save remembers this connection · /login PROVIDER')];
+  return lines.join('\n');
+}
+
+/**
+ * Comandos de sesión. `limits` es el objeto vivo de límites de cli.mjs y se
+ * muta sólo después de validar. `state()` devuelve datos ya proyectados.
+ */
+export class SessionSettings {
+  constructor({ limits, flags = {}, env = process.env, authManager, state, applyLimits = async () => {}, delegate, persistLimits = saveLimits, persistConnection = saveConnection }) {
+    Object.assign(this, { limits, flags, env, authManager, state, applyLimits, delegate, persistLimits, persistConnection });
+  }
+  handles(command) { return ['config', 'max-tokens', 'context-window'].includes(command); }
+  file() { return connectionPreferenceFile(this.env); }
+  async control(command, arg = '') {
+    if (command === 'max-tokens' || command === 'context-window') return arg.trim() ? this.setLimit(command, arg) : this.describeLimit(command);
+    const action = parseConfigCommand(arg);
+    if (action.action === 'show') return formatConfig(await this.view());
+    if (action.action === 'save') return this.saveDefault();
+    if (['max-tokens', 'context-window'].includes(action.key)) return this.setLimit(action.key, action.value);
+    return this.delegate(action.key, action.value);
+  }
+  describeLimit(key) {
+    const budget = this.budget();
+    if (key === 'max-tokens') return t('Max tokens: {value} · source {source}', { value: this.limits.maxTokens, source: sourceLabel(this.limits.maxTokensSource) });
+    return t('Context window: {value} · {kind} · source {source} · announced {announced} · explicit limit {limit}', { value: budget.contextWindow, kind: budget.kind, source: sourceLabel(budget.source), announced: budget.announcedWindow ?? t('unknown'), limit: budget.configuredLimit ?? t('none') });
+  }
+  budget() { try { return resolveContextBudget(this.limits, this.state().modelCapabilities); } catch { return { contextWindow: this.limits.contextWindow, kind: 'unknown', source: this.limits.contextWindowSource }; } }
+  async setLimit(key, text) {
+    const value = parseLimit(key, text), candidate = nextLimits(this.limits, key, value);
+    checkLimits(candidate, this.state().modelCapabilities);
+    Object.assign(this.limits, candidate);
+    await this.applyLimits();
+    const lines = [this.describeLimit(key), t('Applied to this session.')];
+    try { await this.persistLimits({ [key]: value }, { env: this.env }); lines.push(t('Saved in {file} for the next sessions.', { file: this.file() })); }
+    catch (error) { lines.push(t('Applied, but not saved: {reason}', { reason: error.message })); }
+    const flag = key === 'max-tokens' ? this.flags.maxTokens : this.flags.contextWindow;
+    const variable = key === 'max-tokens' ? 'COMAL_MAX_TOKENS' : 'COMAL_CONTEXT_WINDOW';
+    if (flag != null) lines.push(t('The startup flag {flag} still wins over the saved value when it is passed.', { flag: '--' + key }));
+    else if (comalEnvironment(this.env)[variable] != null) lines.push(t('The environment variable {name} still wins over the saved value.', { name: variable }));
+    return lines.join('\n');
+  }
+  async saveDefault() {
+    const s = this.state();
+    if (s.demo) throw new Error(t('The demo has no connection to save.'));
+    let selection;
+    if (s.authProvider) selection = { 'auth-provider': s.authProvider, ...(s.model ? { model: s.model } : {}) };
+    else if (s.profile) throw new Error(t('Profiles are selected with defaultProfile in {file}; nothing was saved.', { file: s.paths?.profiles || '.comal/providers.json' }));
+    else if (s.provider === 'openai' && s.endpoint) selection = { provider: 'openai', 'base-url': s.endpoint, ...(s.model ? { model: s.model } : {}) };
+    else throw new Error(t('Profiles are selected with defaultProfile in {file}; nothing was saved.', { file: s.paths?.profiles || '.comal/providers.json' }));
+    await this.persistConnection(selection, { env: this.env });
+    return t('Default connection saved in {file}: {summary}. Startup flags still win.', { file: this.file(), summary: Object.entries(selection).map(([k, v]) => `${k}=${v}`).join(' ') });
+  }
+  async view() {
+    const s = this.state();
+    let login = null;
+    if (s.authProvider && AUTH_PROVIDERS.some(item => item.id === s.authProvider)) {
+      try { const status = await this.authManager.status(s.authProvider); login = { status: status.status, method: status.method, ...(status.expiresAt ? { expiresAt: status.expiresAt } : {}) }; }
+      catch { login = { status: 'unknown', method: 'unknown' }; }
+    }
+    return { demo: s.demo, provider: s.provider, authProvider: s.authProvider, profile: s.profile, endpoint: s.endpoint, model: s.model, effort: s.effort, thinking: s.thinking,
+      apiKeyEnv: s.apiKeyEnv, apiKeyDefined: Boolean(s.apiKeyEnv && this.env[s.apiKeyEnv]), login, budget: this.budget(), limits: { ...this.limits }, mode: s.mode, plugins: s.plugins,
+      paths: [['connection', this.file()], ['credentials', this.authManager?.directory || ''], ...(s.paths?.profiles ? [['profiles', s.paths.profiles]] : []), ...(s.paths?.plugins ? [['plugins', s.paths.plugins]] : [])] };
+  }
+}

package/src/context-pressure.mjs

@@ -1,5 +1,6 @@
 import { digest } from './operations.mjs';
 import { auditExecution } from './audit.mjs';
+import { isHumanIntentRecord } from './trusted-context.mjs';
 
 // A view change only. Full receipts and the original visible messages remain in
 // the append-only book. No model-generated claims authorize this substitution.
@@ -42,7 +43,7 @@ export function rapidPressureCount(rows, {maxModelRequests=3}={}) {
   let requests=0,count=0;
   for(let index=rows.length-1;index>=0;index--){
     const row=rows[index];
-    if(row.type==='reset' || row.type==='intent')break;
+    if(row.type==='reset' && !row.source || isHumanIntentRecord(row))break;
     if(row.type==='model_request')requests++;
     if(requests>maxModelRequests)break;
     if(row.type==='context_projection' && row.reason!=='manual')count++;

package/src/durable-agent-runs.mjs

@@ -1,5 +1,3 @@
-import { mkdir, open } from 'node:fs/promises';
-import { sealRecord } from './audit.mjs';
 import { digest } from './operations.mjs';
 import { turnOutcome as executionOutcome } from './execution-metrics.mjs';
 
@@ -10,23 +8,19 @@ export function agentRuns(rows) {
   return [...runs.values()];
 }
 export function publicAgentRun(run) {
-  const keys = ['run_id', 'launch_id', 'session_id', 'parent_session_id', 'parent_invocation_id', 'turn_id', 'description', 'subagent_type', 'max_turns', 'runner_state', 'turn_state', 'work_state', 'status', 'delivery_state', 'background', 'async_launched', 'asked', 'work_stop_reason', 'yielded', 'result', 'result_truncated', 'turns', 'usage', 'evidence', 'house', 'result_ref', 'error', 'manual_stop', 'outcome', 'phase'];
+  const keys = ['run_id', 'launch_id', 'session_id', 'parent_session_id', 'parent_invocation_id', 'turn_id', 'description', 'subagent_type', 'max_turns', 'runner_state', 'turn_state', 'work_state', 'status', 'delivery_state', 'background', 'async_launched', 'asked', 'work_stop_reason', 'work_stop_cause', 'turn_termination', 'yielded', 'result', 'result_truncated', 'turns', 'usage', 'evidence', 'house', 'result_ref', 'result_read_call','error','code', 'manual_stop', 'outcome', 'phase','source_workspace','source_offer'];
   return Object.fromEntries(keys.filter(key => run[key] !== undefined).map(key => [key, run[key]]));
 }
 export function turnOutcome(result = {}) {
   const outcome = executionOutcome(result), cause = outcome.turn;
   return { runner_state: outcome.runner, turn_state: cause, work_state: outcome.work, asked: 'unjudged',
-    status: ['failed', 'cancelled'].includes(cause) ? cause : ['budget', 'no_progress', 'permission_denied', 'blocked', 'plan_mode', 'yielded'].includes(cause) ? 'paused' : 'completed',
-    ...(result.work_stop_reason ? { work_stop_reason: result.work_stop_reason } : {}), ...(result.yielded ? { yielded: true } : {}) };
+    status: ['failed', 'cancelled'].includes(cause) ? cause : ['budget', 'no_progress', 'permission_denied', 'native_refused', 'blocked', 'plan_mode', 'yielded'].includes(cause) ? 'paused' : 'completed',
+    ...(result.work_stop_reason ? { work_stop_reason: result.work_stop_reason, ...(result.work_stop_cause?{work_stop_cause:structuredClone(result.work_stop_cause)}:{}) } : {}), ...(result.turn_termination ? { turn_termination: structuredClone(result.turn_termination) } : {}), ...(result.yielded ? { yielded: true } : {}) };
 }
 // Child identity is reserved in the parent BEFORE file creation. Reconciliation
 // creates the same UUID, so a kill between the two journals cannot spawn twice.
 export async function ensureAgentSession(store, run) {
-  await mkdir(store.dir, { recursive: true, mode: 0o700 });
-  let file;
-  try { file = await open(store.file(run.session_id), 'wx', 0o600); }
-  catch (error) { if (error.code !== 'EEXIST') throw error; }
-  if (file) try { await file.writeFile(JSON.stringify(sealRecord({ type: 'session', id: run.session_id, cwd: store.cwd, model: run.configuration.model, provider: run.configuration.provider, created_at: run.created_at }, 0)) + '\n'); await file.sync(); } finally { await file.close(); }
+  await store.reserve({id:run.session_id,model:run.configuration.model,provider:run.configuration.provider,created_at:run.created_at});
   return store.workTransaction(run.session_id, async () => {
     const session = await store.load(run.session_id);
     if (!session.journalAudit.consistent) throw Object.assign(new Error('Libro hijo alterado.'), { code: 'AUDIT_INVALID' });
@@ -37,4 +31,4 @@ export async function ensureAgentSession(store, run) {
     return store.load(run.session_id);
   });
 }
-export function outcomeDigest(item) { return digest({ run_id: item.run_id, turn_id: item.turn_id, result_ref: item.result_ref, turn_state: item.turn_state, work_state: item.work_state, result: item.result, evidence: item.evidence }); }
+export function outcomeDigest(item) { return digest({ run_id: item.run_id, turn_id: item.turn_id, result_ref: item.result_ref, turn_state: item.turn_state, work_state: item.work_state, result: item.result, evidence: item.evidence,...(item.source_offer?{source_offer:item.source_offer}:{}) }); }

package/src/event-channels.mjs

@@ -0,0 +1,8 @@
+// Classifier output belongs only to permission decision/result records. This check
+// deliberately does not claim to authenticate arbitrary journal authorship.
+export const inadmissibleClassifierRecord = row => ['classifier', 'classifier-error'].includes(row.source) && !['auto_decision', 'permission'].includes(row.type);
+export const classifierChannelViolations = rows => rows.flatMap((row, index) => inadmissibleClassifierRecord(row) ? [{ row: index, reason: 'classifier_record_channel_mismatch' }] : []);
+export function assertClassifierChannels(rows) {
+  const violations = classifierChannelViolations(rows);
+  if (violations.length) throw Object.assign(new Error('Classifier records outside their decision channel; session cannot resume. The original journal is preserved for inspection.'), { code: 'JOURNAL_SOURCE_MISMATCH', violations });
+}

package/src/file-recovery-proof.mjs

@@ -1,9 +1,13 @@
+import {sourceTaskRecoveryValid} from './source-task-proof.mjs';
+import {sourcePublicationLeafValid,sourceRecoveryValid} from './source-proposal-proof.mjs';
+import {gitIntegrationRecoveryValid} from './git-integration-recovery-proof.mjs';
 import { digest } from './operations.mjs';
 import { workLeafValid, workRecoveryValid } from './work-recovery-proof.mjs';
 import { chromeRecoveryValid,chromeObservationRetryValid } from './chrome-recovery-proof.mjs';
 import { agentRecoveryValid } from './agent-recovery-proof.mjs';
-export const recoveryAttribution=kind=>({file_postcondition:'not_established',not_started:'handler_not_entered',read_interrupted:'read_result_unavailable',work_not_dispatched:'no_completed_mutation_dispatch',work_child_receipts:'recorded_child_receipts',work_draft_saved:'recorded_draft_chunk',chrome_publication:'observed_publication_only',chrome_observation_retry:'read_result_unavailable',agent_launch_recorded:'registered_children_only',agent_not_dispatched:'no_child_dispatch',agent_read_retry:'read_result_unavailable',agent_control_recorded:'control_handler_return_unavailable'})[kind] || 'unknown';
-export function nativeRecoveryRead(rows,p){const c=rows.findLast(r=>r.type==='house_contract'&&r.contract_digest===p.contract_digest)?.contract;return ['Read','Glob','Grep','ListDirectory','FileInfo'].includes(p.operation)&&c?.origin===null&&c.name===p.operation&&c.effects.workspace==='read'&&c.effects.external==='none'&&c.permission===p.operation;}
+import { chromeCandidateRecoveryValid } from './chrome-candidate-recovery-proof.mjs';
+export const recoveryAttribution=kind=>({file_postcondition:'not_established',not_started:'handler_not_entered',source_recorded:'recorded_source_children_not_delivery',source_task_recorded:'recorded_source_task_children_not_delivery',source_task_read:'read_result_unavailable',read_interrupted:'read_result_unavailable',work_not_dispatched:'no_completed_mutation_dispatch',work_child_receipts:'recorded_child_receipts',work_draft_saved:'recorded_draft_chunk',chrome_candidate:'recorded_candidate_children_not_current_delivery',chrome_publication:'observed_publication_only',chrome_observation_retry:'read_result_unavailable',agent_launch_recorded:'registered_children_only',agent_not_dispatched:'no_child_dispatch',agent_read_retry:'read_result_unavailable',agent_control_recorded:'control_handler_return_unavailable',git_integration_revision_call:'recorded_revision_composition_not_current_delivery',git_integration_intent:'registered_git_intent_not_current_delivery',git_integration_not_dispatched:'no_git_dispatch_from_this_handler'})[kind] || 'unknown';
+export function nativeRecoveryRead(rows,p){const c=rows.findLast(r=>r.type==='house_contract'&&r.contract_digest===p.contract_digest)?.contract;return ['Read','Glob','Grep','ListDirectory','FileInfo','GitInspect','GitIntegrationStatus','GitIntegrationEvidence','SourceRead'].includes(p.operation)&&c?.origin===null&&c.name===p.operation&&c.effects.workspace==='read'&&c.effects.external==='none'&&c.permission===p.operation&&(p.operation!=='GitInspect'||!c.steps&&c.effects.process==='read'&&c.effects.authority==='none');}
 
 export const recoveredFileOutput = preparation => JSON.stringify({...JSON.parse(preparation.output),status:'postcondition_observed',prepared_status:JSON.parse(preparation.output).status,recovered:true,handler_return:'unavailable',attribution:'not_established'});
 export function filePreparationValid(...args) {try{return preparationValid(...args);}catch{return false;}}
@@ -28,11 +32,15 @@ function receiptValid(rows,index,row) {
   const begins=rows.slice(r.proposal_ref+1,index).filter(e=>e.type==='house_started' && e.invocation_id===row.invocation_id);
   if(begins.some(begin=>['parent_invocation_id','operation','arguments_digest','contract_digest','actor','surface','work','house','session_id','execution_process'].some(key=>digest(begin[key]??null)!==digest(proposal[key]??null))))return false;
   if(r.kind==='read_interrupted')return begins.length===1 && nativeRecoveryRead(rows.slice(0,index),proposal) && row.status==='refused' && row.code==='HOUSE_RECOVERY_READ_RETRY' && row.effects_observed==='read_only' && !rows.slice(r.proposal_ref,index).some(e=>e.type==='house_proposal' && e.parent_invocation_id===proposal.invocation_id);
+  if(r.kind==='source_task_recorded'||r.kind==='source_task_read')return begins.length===1&&sourceTaskRecoveryValid(rows,index,row);
+  if(r.kind==='source_recorded')return begins.length===1&&sourceRecoveryValid(rows,index,row);
+  if(r.kind.startsWith('git_integration_'))return begins.length===1&&gitIntegrationRecoveryValid(rows,index,row);
   if(r.kind.startsWith('agent_'))return begins.length===1 && agentRecoveryValid(rows,index,row);
   if(r.kind.startsWith('work_'))return begins.length===1 && workRecoveryValid(rows,index,row);
   if(r.kind==='chrome_publication')return chromeRecoveryValid(rows,index,row);
+  if(r.kind==='chrome_candidate')return begins.length===1&&chromeCandidateRecoveryValid(rows,index,row);
   if(r.kind==='chrome_observation_retry')return chromeObservationRetryValid(rows,index,row);
-  if(!workLeafValid(rows,proposal))return false;
+  if(!workLeafValid(rows,proposal)&&!sourcePublicationLeafValid(rows,proposal))return false;
   if(r.kind==='not_started')return !begins.length && row.status==='refused' && row.effects_observed==='none' && row.code==='HOUSE_RECOVERY_NOT_STARTED';
   if(r.kind!=='file_postcondition' || row.status!=='returned' || row.judgment_scope!=='observed_file_postcondition_not_handler_return' || begins.length!==1 || !Number.isSafeInteger(r.preparation_ref) || !Number.isSafeInteger(r.observation_ref) || r.preparation_ref<=r.proposal_ref || r.observation_ref<=r.preparation_ref || r.observation_ref>=index)return false;
   const prepared=rows[r.preparation_ref], read=rows[r.observation_ref], contract=rows.slice(0,r.proposal_ref).findLast(e=>e.type==='house_contract' && e.contract_digest===proposal.contract_digest)?.contract;

package/src/file-recovery.mjs

@@ -1,3 +1,6 @@
+import {nativeSourceTask,sourceTaskRecoveryPlan} from './source-task-proof.mjs';
+import {nativeSourceParent,sourceRecoveryPlan} from './source-proposal-proof.mjs';
+import {nativeGitIntegration,gitIntegrationRecoveryPlan} from './git-integration-recovery-proof.mjs';
 import { randomUUID } from 'node:crypto';
 import { auditExecution } from './audit.mjs';
 import { digest } from './operations.mjs';
@@ -6,6 +9,7 @@ import { filePreparationValid, recoveredFileOutput, recoveryReceiptValid,nativeR
 import { nativeWorkParent, workRecoveryPlan } from './work-recovery-proof.mjs';
 import { chromeRecoveryMessage,chromeObservationMessage } from './chrome-recovery-proof.mjs';
 import { nativeDelegation, agentRecoveryPlan } from './agent-recovery-proof.mjs';
+import { nativeChromeCandidate, chromeCandidateRecoveryPlan } from './chrome-candidate-recovery-proof.mjs';
 
 function pendingFromDeadProcess(session,actor,active=new Set()){
   const closed=new Set(session.rows.filter(r=>r.type==='house_receipt').map(r=>r.invocation_id)), starts=new Set(session.rows.filter(r=>r.type==='house_started').map(r=>r.invocation_id)), owners=new Map();
@@ -63,11 +67,31 @@ async function reconcile({store,house,executor,sessionId,actor,signal}) {
     else if(nativeRecoveryRead(session.rows,p)){
       recovery.kind='read_interrupted';receipt={...base,type:'house_receipt',source:'recovery_host',status:'refused',code:'HOUSE_RECOVERY_READ_RETRY',error:'Lectura nativa interrumpida sin resultado durable. Puede repetirse bajo permisos actuales; no se reconstruyeron bytes ni se repitió una mutación.',effects_observed:'read_only',observations:[],asked:'unjudged',recovery};
     }
+    else if(nativeSourceTask(session.rows,p)){
+      const plan=sourceTaskRecoveryPlan(session.rows,p);if(!plan)return blocked('The original accepted source task/children do not verify; no stage was replayed.');
+      recovery.kind=plan.kind;recovery.plan_digest=digest(plan);receipt={...base,type:'house_receipt',source:'recovery_host',status:'refused',code:plan.code,error:plan.error,effects_observed:plan.effects_observed,observations:[],asked:'unjudged',recovery};
+    }
+    else if(nativeSourceParent(session.rows,p)){
+      const plan=sourceRecoveryPlan(session.rows,p);if(!plan)return blocked('The retained-source children have unsettled or incompatible outcomes; nothing was replayed.');
+      recovery.kind=plan.kind;recovery.plan_digest=digest(plan);
+      receipt={...base,type:'house_receipt',source:'recovery_host',status:'refused',code:plan.code,error:plan.error,effects_observed:plan.effects_observed,observations:[],asked:'unjudged',recovery};
+    }
     else if(nativeDelegation(session.rows,p)){
       const plan=agentRecoveryPlan(session.rows,p);if(!plan)return blocked('No valida la preparación original o el parentesco del lanzamiento delegado');
       recovery.kind=plan.kind;recovery.plan_digest=digest(plan);
       receipt={...base,type:'house_receipt',source:'recovery_host',status:'refused',code:plan.code,error:plan.error,effects_observed:plan.effects_observed,judgment_scope:'registered_child_execution_not_delivery',observations:[],asked:'unjudged',recovery};
     }
+    else if(nativeGitIntegration(session.rows,p)){
+      const plan=gitIntegrationRecoveryPlan(session.rows,p);if(!plan)return blocked('The original native Git intent does not verify.');
+      recovery.kind=plan.kind;recovery.plan_digest=digest(plan);
+      receipt={...base,type:'house_receipt',source:'recovery_host',status:'refused',code:plan.code,error:plan.error,effects_observed:plan.effects_observed,observations:[],asked:'unjudged',recovery};
+    }
+    else if(nativeChromeCandidate(session.rows,p)){
+      const plan=chromeCandidateRecoveryPlan(session.rows,p);if(!plan)return blocked('Candidate children contain an uncertain or incompatible effect; no child is replayed.');
+      recovery.kind='chrome_candidate';recovery.plan_digest=digest(plan);
+      const contract=session.rows.findLast(r=>r.type==='house_contract'&&r.contract_digest===p.contract_digest)?.contract;
+      receipt={...base,type:'house_receipt',source:'recovery_host',status:plan.status,observations:[],asked:'unjudged',recovery,...(plan.status==='returned'?{effects:contract.effects,disposition:'serve',judgment_scope:'recorded_child_execution_not_current_delivery',authority:'reconstructed_child_receipts',output:plan.output,output_digest:digest(plan.output),output_truncated:false}:{code:plan.code,error:plan.error,effects_observed:plan.effects_observed})};
+    }
     else if(nativeWorkParent(session.rows,p)){
       const plan=workRecoveryPlan(session.rows,p);if(!plan)return blocked('El coordinador no tiene hechos/hijos completos y compatibles para reconstruir su respuesta');
       recovery.kind=plan.kind;recovery.plan_digest=digest(plan);

package/src/gemini-provider.mjs

@@ -67,7 +67,12 @@ export function toGeminiContents(messages, capabilities) {
 }
 
 function normalize(parts, finishReason, usage, groundingMetadata, usage_accounting) {
-  if (finishReason === 'MAX_TOKENS') throw Object.assign(new Error('Respuesta Gemini truncada; no se ejecutaron herramientas.'), { code: 'OUTPUT_LENGTH', usage, usage_accounting });
+  if (finishReason === 'MAX_TOKENS') {
+    const last = parts.at(-1), size = (pick) => parts.reduce((sum, part) => sum + pick(part), 0);
+    const details = { text_chars: size(part => typeof part.text === 'string' && !part.thought ? part.text.length : 0), reasoning_chars: size(part => typeof part.text === 'string' && part.thought ? part.text.length : 0),
+      tool_argument_chars: size(part => part.functionCall ? JSON.stringify(part.functionCall.args ?? {}).length : 0), ...(typeof last?.functionCall?.name === 'string' && last.functionCall.name ? { tool_name: last.functionCall.name } : {}) };
+    throw Object.assign(new Error('Respuesta Gemini truncada; no se ejecutaron herramientas.'), { code: 'OUTPUT_LENGTH', usage, usage_accounting, details });
+  }
   if (finishReason !== 'STOP') throw new Error(`Respuesta Gemini incompleta (${finishReason || 'stream interrumpido'}); no se ejecutaron herramientas.`);
   const content = [], ids = new Set();
   for (const part of parts) {

package/src/git-agent-revision.mjs

@@ -0,0 +1,12 @@
+import{digest}from'./operations.mjs';
+import{scopeCeiling,validateScopeCeiling}from'./scope-ceiling.mjs';
+import{integrationLineage}from'./git-integration-lineage.mjs';
+export function joinRevisionCeilings(a,b,cwd,parent){a=validateScopeCeiling(a,{house:cwd,session_id:parent});b=validateScopeCeiling(b,{house:cwd,session_id:parent});const unique=items=>[...new Map(items.map(v=>[digest(v),v])).values()];return scopeCeiling({schema:a.schema,parent:a.parent,laws:unique([...a.laws,...b.laws]),guards:unique([...a.guards,...b.guards])});}
+// Historical binding only; current native resource/goal/authority are checked by
+// the admitted host frame and the child runtime, never inferred from this row.
+export function revisionOrigin(rows,task,workspace,{parentId,actor,cwd}={}){
+ if(!task.git_revision)return workspace?.revision_source||workspace?.revision_origin?undefined:null;
+ try{const link=workspace.revision_origin,r=rows[link.row],s=workspace.revision_source,b=r.binding,k=b.resolved.kernel_input;if(r.type!=='git_integration_intent'||r.source!=='git_integration_host'||r.mechanism!=='comal-git-integration-v1'||r.operation!=='GitIntegrationPrepare'||r.session_id!==parentId||r.cwd!==cwd||r.audit.sha256!==link.digest||r.binding_digest!==digest(b)||r.binding_digest!==link.binding_digest||r.owner_digest!==digest(b.owner)||digest(b.owner)!==digest({actor,session_id:parentId})||r.input_digest!==digest(r.input)||b.resolved.integration_id!==task.git_revision||workspace.source!=='revision'||workspace.expected_source_identity!==digest(s)||s.integration_id!==task.git_revision||s.owner_digest!==r.owner_digest||s.verification_digest!==digest(k.verification)||s.target!==k.target||s.expected_target!==k.expected_target||s.base_commit!==k.base_commit||task.isolation!=='git'||task.work_tracking!=='parent'||task.git_source||task.run_in_background)return undefined;
+  const joined=validateScopeCeiling(workspace.ceiling,{house:cwd,session_id:parentId});for(const ancestor of integrationLineage(rows,r)){const original=validateScopeCeiling(ancestor.binding.ceiling,{house:cwd,session_id:parentId});for(const key of ['laws','guards'])if(original[key].some(v=>!joined[key].some(j=>digest(j)===digest(v))))return undefined;}return r;
+ }catch{return undefined;}
+}

package/src/git-agent-workspaces.mjs

@@ -0,0 +1,143 @@
+import {GitIntegrationOperations} from './git-integration-operations.mjs';
+import {revisionOrigin,joinRevisionCeilings} from './git-agent-revision.mjs';
+import {preparedEditorRole,reservedEditorRole} from './source-editor-role.mjs';
+import path from 'node:path';
+import {realpath} from 'node:fs/promises';
+import {SessionStore} from './sessions.mjs';
+import {GitWorkspaces,gitWorkspaceResourceId} from './git-workspaces.mjs';
+import {inspectGitSource} from './git-source.mjs';
+import {readGit} from './git-plumbing.mjs';
+import {digest} from './operations.mjs';
+import {auditExecution} from './audit.mjs';
+import {toolDefinitions} from './tools.mjs';
+import {WORK_NAMES,registerWorkOperations} from './work-plan.mjs';
+import {evidenceOperations} from './work-state.mjs';
+import {ensureAgentSession} from './durable-agent-runs.mjs';
+
+export const GIT_AGENT_MECHANISM='comal-git-agent-v1';
+const fail=(message,code='AGENT_GIT_BINDING_INVALID')=>Object.assign(new Error(message),{code});
+const sourceTools=new Set([...toolDefinitions.map(tool=>tool.name),...WORK_NAMES,'EvidenceRead']);
+export const agentKind=task=>task.subagent_type||(task.isolation==='git'?'general':'explore');
+export const gitAgentActor=run=>({id:run.session_id,kind:'subagent',parent_session_id:run.parent_session_id});
+const owner=run=>({actor:gitAgentActor(run),session_id:run.session_id});
+const ref=(book,index)=>({session_id:book.id,row:index,digest:book.rows[index].audit.sha256});
+
+// Native source/runtime port. It does not copy a plugin registry or acquire a
+// provider slot; SubagentManager keeps original run, turn and budget leases.
+export class GitAgentWorkspaces {
+ constructor({cwd,house,store,policy,kernel=new GitWorkspaces({cwd}),fault=async()=>{}}){Object.assign(this,{cwd,house,store,policy,kernel,fault});this.stores=new Map();this.revisionFrames=new Map();}
+ async prepare(tasks,parentSessionId,signal,options={}){
+  if(!tasks.some(task=>task.isolation==='git'))return tasks.map(()=>null);
+  for(const task of tasks.filter(task=>task.isolation==='git')){
+   if(agentKind(task)!=='general')throw fail('Git isolation currently accepts native general source tasks.','AGENT_GIT_SCOPE');
+   if((task.tools||[]).some(name=>!sourceTools.has(name)))throw fail('An isolated source agent needs an explicit workspace-aware port for plugin/web/MCP operations. No root-bound closure was copied.','AGENT_GIT_SCOPE');
+  }
+  const identity=await inspectGitSource({cwd:this.cwd,signal}),ceiling=this.house.captureScopeCeiling(parentSessionId);
+  return Promise.all(tasks.map(async task=>{
+   if(task.isolation!=='git')return null;
+   if(!task.git_revision)return{kind:'git',source:task.git_source||'working',expected_source_identity:identity.source_identity,repository_root:identity.repository.root,ceiling};
+   if(!options.actor||typeof options.revalidate!=='function'||!this.policy)throw fail('Native revision admission requires an active owned Agent frame.','AGENT_REVISION_FRAME_REQUIRED');
+   await this.revisionAdmission(options,parentSessionId);
+   const service=new GitIntegrationOperations({cwd:this.cwd,house:this.house,store:this.store,policy:this.policy}),context={...options,sessionId:parentSessionId},original=await service.preparation(context,task.git_revision),chain=await service.lineage(context,original);if(chain.some(i=>i.binding.authority.denied.includes('Agent'))||this.policy.denied.has('Agent')||this.policy.mode==='plan')throw fail('The original/current native delegation ceiling refuses this revision.','HOUSE_REFUSED');await service.frame(context,chain);
+   const source=await this.kernel.revisionSource(task.git_revision,{owner:original.binding.owner,signal}),book=await this.store.load(parentSessionId);
+   return{kind:'git',source:'revision',expected_source_identity:digest(source),repository_root:identity.repository.root,ceiling:chain.reduce((a,i)=>joinRevisionCeilings(a,i.binding.ceiling,this.cwd,parentSessionId),ceiling),revision_source:source,revision_origin:{row:book.rows.findIndex(r=>r.audit.sha256===original.audit.sha256),digest:original.audit.sha256,binding_digest:original.binding_digest}};
+  }));
+ }
+ reservation(run,input){return input?{...input,workspace_id:gitWorkspaceResourceId(input.repository_root,owner(run),run.run_id),request_id:run.run_id}:undefined;}
+ async validate(run,book){
+  if(!run.workspace){if(run.task?.isolation==='git')throw fail('A Git task cannot fall back to the shared workspace.');return;}
+  const initial=book.rows.find(row=>row.type==='subagent'&&row.source==='delegation_host'&&row.runner_state==='reserved'&&row.run_id===run.run_id),prepared=book.rows.find(row=>row.type==='agent_launch_prepared'&&row.source==='delegation_host'&&row.invocation_id===run.parent_invocation_id),index=prepared&&(prepared.operation==='AgentBatch'?prepared.input.tasks:[prepared.input]).findIndex((_,i)=>run.launch_id===`${prepared.invocation_id}:${i}`);
+  if(!book.journalAudit.verified||!initial||index<0||!prepared?.workspace_inputs?.[index]||digest(initial.workspace)!==digest(run.workspace)||digest(this.reservation(run,prepared.workspace_inputs[index]))!==digest(run.workspace)||preparedEditorRole(prepared,index)===undefined||initial.system!==(preparedEditorRole(prepared,index)?.system??prepared.system)||digest(initial.editor_role??null)!==digest(reservedEditorRole(prepared,index))||digest(run.editor_role??null)!==digest(initial.editor_role??null)||initial.session_id!==run.session_id||initial.parent_session_id!==run.parent_session_id||initial.input_digest!==digest(run.task)||run.workspace.repository_root!==await realpath(this.cwd))throw fail('The saved Git run differs from its original parent reservation.');
+  if(revisionOrigin(book.rows,run.task,run.workspace,{parentId:run.parent_session_id,actor:prepared.actor,cwd:this.cwd})===undefined)throw fail('The revision origin or inherited source constraints changed.','AGENT_REVISION_BINDING');
+ }
+ async revisionAdmission(options,parentId){
+  if(typeof options?.revalidate!=='function'||options.sessionId!==parentId)throw fail('A revision needs an admitted native delegation invocation.','AGENT_REVISION_FRAME_REQUIRED');
+  const observed=await options.revalidate(),book=await this.store.load(parentId),proposal=book.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===options.invocation_id),contract=book.rows.find(r=>r.type==='house_contract'&&r.contract_digest===proposal?.contract_digest)?.contract;
+  if(observed?.invocation_id!==options.invocation_id||!proposal||!['Agent','AgentBatch','AgentContinue','AgentResume'].includes(proposal.operation)||proposal.operation!==options.command_name||proposal.session_id!==parentId||proposal.house!==this.cwd||digest(proposal.actor)!==digest(options.actor)||contract?.name!==proposal.operation||contract.origin?.plugin!=='delegation'||contract.origin.builtin!==true||!contract.description.includes('comal-delegation-v1'))throw fail('A read/plugin frame cannot create, resume or publish a revision editor.','AGENT_REVISION_FRAME_REQUIRED');
+ }
+ releaseRevisionFrames(invocation){if(invocation)for(const[id,value]of this.revisionFrames)if(value.invocation_id===invocation)this.revisionFrames.delete(id);}
+ async originalRevision(run){
+  const book=await this.store.load(run.parent_session_id);if(!book.journalAudit.verified||auditExecution(book,this.house.stateContext()).violations.length)throw fail('The original revision parent book does not verify.','AUDIT_INVALID');await this.validate(run,book);const prepared=book.rows.find(r=>r.type==='agent_launch_prepared'&&r.invocation_id===run.parent_invocation_id),original=revisionOrigin(book.rows,run.task,run.workspace,{parentId:run.parent_session_id,actor:prepared.actor,cwd:this.cwd});
+  if(!original)throw fail('The original revision integration does not verify.','AGENT_REVISION_BINDING');
+  const service=new GitIntegrationOperations({cwd:this.cwd,house:this.house,store:this.store,policy:this.policy}),chain=await service.lineage({actor:prepared.actor,sessionId:run.parent_session_id},original);if(chain.some(i=>i.binding.goal_owner!==(book.goal?.status==='active'?book.goal.id:null)))throw fail('The original revision execution goal changed.','GIT_GOAL_CHANGED');
+  await this.kernel.validateRevisionSource(run.workspace.revision_source,{owner:original.binding.owner});return original;
+ }
+ async revisionFrame(run,options=this.revisionFrames.get(run.run_id)){
+  if(typeof options?.revalidate!=='function'||options.sessionId!==run.parent_session_id)throw fail('Continue this revision through an admitted native Agent/Continue/Resume frame. Reads do not allocate or publish a correction.','AGENT_REVISION_FRAME_REQUIRED');
+  await this.revisionAdmission(options,run.parent_session_id);
+  const original=await this.originalRevision(run),service=new GitIntegrationOperations({cwd:this.cwd,house:this.house,store:this.store,policy:this.policy}),chain=await service.lineage(options,original);if(chain.some(i=>i.binding.authority.denied.includes('Agent'))||this.policy.denied.has('Agent')||this.policy.mode==='plan')throw fail('The original/current native delegation ceiling refuses this revision.','HOUSE_REFUSED');await service.frame(options,chain);return original;
+ }
+ async admitRevision(run,options){this.revisionFrames.set(run.run_id,options);return this.revisionFrame(run,options);}
+ async allocation(run,signal,options){
+  if(!run.workspace)return;
+  if(run.task.git_revision&&options?.revalidate)this.revisionFrames.set(run.run_id,options);
+  // Settled allocation is a fact, even after logical retirement. Historical
+  // evidence lookup must not re-enter a mutation merely to find its journal.
+  try{const status=await this.kernel.status(run.workspace.workspace_id,{owner:owner(run)}),opened=status.completed.find(row=>row.action==='open')?.output;if(opened)return opened;}catch(error){if(!['ENOENT','GIT_RESOURCE_UNINITIALIZED'].includes(error.code))throw error;}
+  const input={request_id:run.workspace.request_id,source:run.workspace.source,expected_source_identity:run.workspace.expected_source_identity};let work;
+  if(run.task.git_revision){const original=await this.revisionFrame(run,options),kernel=new GitWorkspaces({cwd:this.cwd,fault:this.kernel.fault,beforeEffect:()=>this.revisionFrame(run)});work=await kernel.openRevision({request_id:run.workspace.request_id,source:run.workspace.revision_source},{owner:owner(run),source_owner:original.binding.owner,signal});}
+  else work=await this.kernel.open(input,{owner:owner(run),signal});
+  if(work.workspace_id!==run.workspace.workspace_id)throw fail('Kernel allocation differs from its reserved resource.');await this.fault('workspace_allocated',{run,work});return work;
+ }
+ async location(run,{live=false}={}){
+  const status=await this.kernel.status(run.workspace.workspace_id,{owner:owner(run)}),opened=status.completed.find(row=>row.action==='open')?.output;
+  if(!opened||status.spec.request_id!==run.workspace.request_id||status.spec.source!==run.workspace.source||status.spec.expected_source_identity!==run.workspace.expected_source_identity||opened.workspace_id!==run.workspace.workspace_id||status.owner.session_id!==run.session_id||digest(status.owner.actor)!==digest(gitAgentActor(run))||opened.path!==path.join(this.kernel.worktrees,'work-'+run.workspace.workspace_id)||await realpath(opened.path)!==opened.path)throw fail('The owned source path, original intent or actor differs from its native resource.');
+  if(run.task.git_revision&&digest(status.spec.revision)!==digest(run.workspace.revision_source))throw fail('Revision workspace selected another native source.','AGENT_REVISION_BINDING');
+  if(live&&(status.lifecycle!=='retained'||status.pending.length))throw fail('The original source resource is retired or has an unsettled Git action.','AGENT_GIT_UNSETTLED');
+  let store=this.stores.get(opened.path);if(!store){store=new SessionStore({cwd:opened.path,stateDir:path.join(opened.path,'.comal')});this.stores.set(opened.path,store);if(this.stores.size>32)this.stores.delete(this.stores.keys().next().value);}
+  return{status,opened,store};
+ }
+ async ensure(run,signal,options){await this.allocation(run,signal,options);const{store}=await this.location(run);await ensureAgentSession(store,run);return store;}
+ async bindRuntime(run){
+  const{status,opened,store}=await this.location(run,{live:true}),book=await store.load(run.session_id),binding={workspace_id:run.workspace.workspace_id,run_id:run.run_id,session_id:run.session_id,parent_session_id:run.parent_session_id,owner_digest:digest(owner(run)),source_root:opened.path,initial_head:opened.head,request_digest:digest(run.workspace)};
+  if(!book.journalAudit.verified)throw fail('The reserved native source session must have a verified journal.');
+  await store.workTransaction(run.session_id,async()=>{
+   const saved=await store.load(run.session_id),existing=saved.rows.filter(row=>row.type==='git_agent_workspace_bound');
+   if(existing.length>1||existing.length&&(existing[0].source!=='git_delegation_host'||existing[0].mechanism!==GIT_AGENT_MECHANISM||digest(existing[0].binding)!==digest(binding)))throw fail('Native child belongs to another workspace/run.');
+   if(!existing.length){if(saved.rows.some(row=>row.type.startsWith('house_')))throw fail('Native effects already exist without the reserved source binding.');await store.append(run.session_id,{type:'git_agent_workspace_bound',source:'git_delegation_host',mechanism:GIT_AGENT_MECHANISM,binding,binding_digest:digest(binding)});}
+  });
+  const saved=await store.load(run.session_id),births=saved.rows.filter(row=>row.type==='house_scope_bound');let house;
+  if(saved.rows.some(row=>row.type==='house_scope_revoked'))throw fail('The child runtime was revoked.','HOUSE_SCOPE_REVOKED');
+  if(births.length)house=await this.house.restoreFork({cwd:opened.path,store,parentSessionId:run.parent_session_id,sessionId:run.session_id});
+  else{if(saved.rows.some(row=>['house_proposal','house_started','house_receipt'].includes(row.type)))throw fail('An unbound scope cannot be created around existing native effects.');house=this.house.fork({cwd:opened.path,record:row=>store.append(row.session_id,row),parentSessionId:run.parent_session_id,sessionId:run.session_id,ceiling:run.workspace.ceiling});}
+  const revision=run.task.git_revision?await this.originalRevision(run):null;
+  const check=async()=>{
+   if(run.task.git_revision)await this.originalRevision(run);
+   const current=await this.location(run,{live:true});
+   const head=(await readGit(opened.path,['rev-parse','--verify','HEAD'])).stdout.toString().trim(),branch=(await readGit(opened.path,['rev-parse','--symbolic-full-name','HEAD'])).stdout.toString().trim(),common=await realpath((await readGit(opened.path,['rev-parse','--path-format=absolute','--git-common-dir'])).stdout.toString().trim());
+   if(head!==opened.head||branch!==opened.branch||common!==current.status.spec.repository.common_directory)throw fail('The source resource changed repository, branch or base; its bytes were preserved.','AGENT_GIT_SOURCE_DIVERGED');return true;
+  };
+  await check();house.guard('git-agent-source',check,{revision:GIT_AGENT_MECHANISM,configuration_digest:digest(binding)});registerWorkOperations({store,house});for(const operation of evidenceOperations({store,house}).filter(op=>op.name==='EvidenceRead'))house.registry.add(operation);
+  const revisionBindings=revision?(await new GitIntegrationOperations({cwd:this.cwd,house:this.house,store:this.store,policy:this.policy}).lineage({actor:revision.binding.owner.actor,sessionId:run.parent_session_id},revision)).map(i=>i.binding):null;
+  return{cwd:opened.path,store,house,actor:gitAgentActor(run),check,...(revision?{revision_binding:revisionBindings}:{}),source_workspace:{workspace_id:opened.workspace_id,path:opened.path,base_commit:opened.head,scope:'owned_native_source_not_browser_or_human_acceptance',...(revision?{revision:{integration_id:run.task.git_revision,kind:run.workspace.revision_source.kind,remaining_source_offers:run.workspace.revision_source.remaining_offers.length,scope:'original_frozen_source_not_permission_or_acceptance'}}:{})}};
+ }
+ async delivery(run,saved,index,signal){
+  const resultRef=ref(saved,index);if(saved.rows[index].type!=='result')return saved;
+  const {store}=await this.location(run);let preparation;
+  await store.workTransaction(run.session_id,async()=>{
+   const book=await store.load(run.session_id);preparation=book.rows.find(row=>row.type==='git_agent_delivery_prepared'&&row.result_ref?.digest===resultRef.digest);
+   if(!preparation){const source=await inspectGitSource({cwd:store.cwd,signal});preparation=await store.append(run.session_id,{type:'git_agent_delivery_prepared',source:'git_delegation_host',mechanism:GIT_AGENT_MECHANISM,result_ref:resultRef,run_id:run.run_id,workspace_id:run.workspace.workspace_id,source_identity:source.source_identity});}
+  });
+  const book=await store.load(run.session_id);if(!book.rows.some(row=>row.type==='git_agent_source_offered'&&row.result_ref?.digest===resultRef.digest)){
+   const kernel=run.task.git_revision?new GitWorkspaces({cwd:this.cwd,fault:this.kernel.fault,beforeEffect:()=>this.revisionFrame(run)}):this.kernel;
+   if(run.task.git_revision)await this.revisionFrame(run);
+   const checkpoint=await kernel.checkpoint(run.workspace.workspace_id,{attempt_id:'result-'+resultRef.digest,expected_source_identity:preparation.source_identity,message:'Comal delegated source '+run.run_id},{owner:owner(run),signal});await this.fault('checkpoint_saved',{run,checkpoint});
+   const offer=await kernel.offer(run.workspace.workspace_id,{attempt_id:'offer-'+resultRef.digest,expected_commit:checkpoint.commit},{owner:owner(run),signal});
+   await store.workTransaction(run.session_id,async()=>{const current=await store.load(run.session_id);if(!current.rows.some(row=>row.type==='git_agent_source_offered'&&row.result_ref?.digest===resultRef.digest))await store.append(run.session_id,{type:'git_agent_source_offered',source:'git_delegation_host',mechanism:GIT_AGENT_MECHANISM,run_id:run.run_id,result_ref:resultRef,offer,scope:'source_offer_not_verification_or_acceptance'});});
+  }
+  const current=await store.load(run.session_id);await this.validateDelivery(run,current);return current;
+ }
+ sourceOffer(run,book,resultRef){
+  const rows=book.rows.filter(row=>row.type==='git_agent_source_offered'&&row.result_ref?.digest===resultRef.digest);if(!rows.length)return;
+  const row=rows[0];if(rows.length!==1||row.source!=='git_delegation_host'||row.mechanism!==GIT_AGENT_MECHANISM||row.run_id!==run.run_id||row.offer?.workspace_id!==run.workspace.workspace_id||digest(row.result_ref)!==digest(resultRef))throw fail('The native child source offer has another result/owner.');return row.offer;
+ }
+ async validateDelivery(run,book){
+  if(!book.journalAudit.verified||auditExecution(book).violations.length)throw fail('The native child source book does not verify.');
+  const{opened}=await this.location(run),bindings=book.rows.filter(row=>row.type==='git_agent_workspace_bound'),binding=bindings[0];
+  if(book.id!==run.session_id||book.cwd!==opened.path||book.parent_session_id!==run.parent_session_id||bindings.length>1||binding&&(binding.source!=='git_delegation_host'||binding.mechanism!==GIT_AGENT_MECHANISM||binding.binding_digest!==digest(binding.binding)||binding.binding.workspace_id!==run.workspace.workspace_id||binding.binding.run_id!==run.run_id||binding.binding.session_id!==run.session_id||binding.binding.parent_session_id!==run.parent_session_id||binding.binding.owner_digest!==digest(owner(run))||binding.binding.source_root!==opened.path||binding.binding.initial_head!==opened.head||binding.binding.request_digest!==digest(run.workspace))||!binding&&book.rows.some(row=>row.type.startsWith('house_')))throw fail('The direct child evidence has another native source/run binding.');
+  for(const row of book.rows.filter(row=>row.type==='git_agent_source_offered')){
+   const fact=book.rows[row.result_ref?.row];if(!fact||fact.audit.sha256!==row.result_ref.digest||row.result_ref.session_id!==book.id)throw fail('A source offer belongs to another result row.');
+   const offer=this.sourceOffer(run,book,row.result_ref),native=await this.kernel.offered({workspace_id:offer.workspace_id,offer_id:offer.offer_id});if(digest(native)!==digest(offer)||offer.metadata.owner_digest!==digest(owner(run)))throw fail('The retained source offer differs from the native kernel.');
+  }
+ }
+}