@panorama-ai/gateway 2.28.50 → 2.29.14

package/dist/index.js

@@ -10,6 +10,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
+import { buildRequestedCancelMetadata, getSubagentCancelAdapter, resolveCancelRequest, GATEWAY_CAPABILITIES_SCHEMA_VERSION, } from '@panorama/shared';
 import { buildMissingSupabaseConfigError, resolveSupabaseConfig, } from './supabase-config.js';
 import { DEFAULT_CLAUDE_SUPPORT, coerceClaudeSupport, parseClaudeSupport, toFlagRecord, } from './subagent-adapters/claude-support.js';
 import { getSubagentAdapter } from './subagent-adapters/registry.js';
@@ -19,24 +20,41 @@ import { DEFAULT_MODEL_SENTINEL } from './cli-providers/types.js';
 import { resolveGatewayConfigDir, resolveGatewayConfigPath, resolveGatewayLogPath, resolveGatewayPidPath, resolveGatewayTmpDir, resolveGatewayWorkdirRoot, resolveModelWorkdirRoot, resolveSubagentWorkdirRoot as resolveSubagentWorkdirRootBase, resolveValidationWorkdirRoot, } from './runtime-paths.js';
 import { sanitizeGatewayDebugPayload } from './debug-redaction.js';
 import { buildGatewayChildProcessEnv } from './child-process-env.js';
+import { evaluateGatewayProviderFullControlSupport } from './subagent-full-control.js';
+import { GatewayJobQueue } from './job-queue.js';
+import { computeGatewayOperationalStatus, } from './gateway-operational-status.js';
 import { ensureOwnerOnlyDirectory, ensureOwnerOnlyFile, shouldEnforceOwnerOnlyPermissions, writeOwnerOnlyFile, } from './local-security.js';
+import { requestChildTermination as terminateChildProcess } from './subagent-process-control.js';
+import { validateRemoteShellResourceRow } from './remote-shell-resource.js';
+import { StreamJsonCollector } from './stream-json-collector.js';
+import { waitForChildStartup } from './child-process-startup.js';
 const execFileAsync = promisify(execFile);
 const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000;
 const DEFAULT_CLAUDE_TIMEOUT_MS = 10_000;
 const DEFAULT_SUBAGENT_TIMEOUT_MS = 30 * 60_000;
 const DEFAULT_MODEL_RUN_TIMEOUT_MS = 110_000;
+const MAX_ACTIVE_SHELL_SESSIONS = 64;
+const MAX_SHELL_SESSION_EVENTS = 800;
+const MAX_SHELL_SESSION_BUFFER_BYTES = 1_000_000;
+const SHELL_SESSION_RETENTION_MS = 15 * 60_000;
+const DEFAULT_SHELL_COLUMNS = 120;
+const DEFAULT_SHELL_ROWS = 40;
 const DEFAULT_GATEWAY_CONCURRENCY = 10;
 const MAX_SUBAGENT_OUTPUT_BYTES = 5_000_000;
+const MAX_SUBAGENT_STREAM_EVENTS = 2000;
+const MAX_SUBAGENT_STREAM_BUFFER_CHARS = 200_000;
 const MAX_SUBAGENT_EVENT_PAYLOAD_BYTES = 200_000;
 const MAX_GATEWAY_LOG_BYTES = 200_000;
 const MAX_GATEWAY_EVENT_MESSAGE_CHARS = 2000;
-const SUBAGENT_EVENT_BATCH_SIZE = 200;
 const SUBAGENT_CANCEL_KILL_TIMEOUT_MS = 5_000;
 const PROCESS_KILL_GRACE_MS = 2_000;
+const DEFAULT_GATEWAY_SHUTDOWN_GRACE_MS = 15_000;
+const DEFAULT_JOB_RECONCILE_INTERVAL_MS = 5_000;
+const DEFAULT_JOB_CHANNEL_RECONNECT_MS = 5_000;
 const PROVIDER_VALIDATION_TIMEOUT_MS = 30_000;
-const GATEWAY_CAPABILITIES_SCHEMA_VERSION = 'v1';
 const DEFAULT_RESTART_CHECK_INTERVAL_MS = 30_000;
 const MAX_CLAUDE_WRAPPER_BYTES = 4096;
+const GATEWAY_HEARTBEAT_STALE_MS = 90_000;
 const PROVIDER_VALIDATION_PROMPT = 'Say hi.';
 const PROVIDER_VALIDATION_SCHEMA = {
     type: 'object',
@@ -61,7 +79,23 @@ const GATEWAY_CONCURRENCY = (() => {
         return DEFAULT_GATEWAY_CONCURRENCY;
     return parsed;
 })();
+const SUBAGENT_RUN_EVENT_TYPES = [
+    'message',
+    'system',
+    'tool_call',
+    'tool_result',
+    'run_started',
+    'run_progress',
+    'cancellation_requested',
+    'cancellation_acknowledged',
+    'run_completed',
+    'run_failed',
+    'run_cancelled',
+];
+const SUBAGENT_RUN_EVENT_TYPE_SET = new Set(SUBAGENT_RUN_EVENT_TYPES);
 const activeSubagentRuns = new Map();
+const activeModelRuns = new Map();
+const activeShellSessions = new Map();
 const pendingCancelByRunId = new Map();
 const pendingCancelBySubagentId = new Map();
 const pendingGatewayEvents = [];
@@ -69,6 +103,9 @@ let CURRENT_CAPABILITIES = null;
 let CURRENT_DEVICE_NAME = null;
 let CURRENT_CONFIG = null;
 let CURRENT_PROVIDER_HEALTH = null;
+let CURRENT_JOB_INGRESS_STATE = null;
+let CURRENT_ACCEPTING_JOBS = true;
+let CURRENT_RUNTIME_OPTIONS = null;
 let ACTIVE_OPTIONS = null;
 function parseArgs(argv) {
     const normalizedArgv = argv[0] === '--' ? argv.slice(1) : argv;
@@ -108,7 +145,7 @@ function parseArgs(argv) {
     return { command, positional, options };
 }
 function printHelp() {
-    console.log(`\nPanorama Gateway\n\nUsage:\n  panorama-gateway pair <PAIRING_CODE> [--device-name \"My Mac\"]\n  panorama-gateway start [--device-name \"My Mac\"] [--foreground|--daemon]\n  panorama-gateway stop\n  panorama-gateway status\n  panorama-gateway logs [--lines 200] [--no-follow]\n  panorama-gateway doctor\n\nNotes:\n  Pair automatically starts the gateway when possible.\n  Start runs in the background by default for the built CLI. Use --foreground to keep it attached.\n\nOutput options:\n  --verbose, -v                     Show technical details (paths, IDs, PIDs)\n\nEnvironment options:\n  --env <local|dev|test|stage|prod>  Load .env.<env> from repo root (defaults to .env)\n  --env-file <path>                 Load a specific env file\n  PANORAMA_ENV                      Same as --env\n  PANORAMA_ENV_FILE                 Same as --env-file\n\nCLI overrides:\n  --config-dir <path>               Override config directory (default: ~/.panorama/gateway)\n  --config-path <path>              Override gateway config file\n  --log-path <path>                 Override gateway log file\n  --pid-path <path>                 Override gateway pid file\n  --claude-cli <path>               Override Claude CLI command\n  --codex-cli <path>                Override Codex CLI command\n  --gemini-cli <path>               Override Gemini CLI command\n\nEnvironment overrides:\n  PANORAMA_GATEWAY_CONFIG_DIR\n  PANORAMA_GATEWAY_CONFIG_PATH\n  PANORAMA_GATEWAY_LOG_PATH\n  PANORAMA_GATEWAY_PID_PATH\n  PANORAMA_CLAUDE_CLI or CLAUDE_CLI\n  PANORAMA_CODEX_CLI or CODEX_CLI\n  PANORAMA_GEMINI_CLI or GEMINI_CLI\n  PANORAMA_GATEWAY_AUTO_RESTART (default: on for built CLI, off for dev)\n  PANORAMA_GATEWAY_RESTART_CHECK_MS (default: 30000)\n  PANORAMA_GATEWAY_RESTART_MAX_WAIT_MS (optional)\n`);
+    console.log(`\nPanorama Gateway\n\nUsage:\n  panorama-gateway pair <PAIRING_CODE> [--device-name \"My Mac\"]\n  panorama-gateway start [--device-name \"My Mac\"] [--foreground|--daemon]\n  panorama-gateway stop\n  panorama-gateway status\n  panorama-gateway logs [--lines 200] [--no-follow]\n  panorama-gateway doctor\n  panorama-gateway full-control <enable|disable|status>\n\nNotes:\n  Pair automatically starts the gateway when possible.\n  Start runs in the background by default for the built CLI. Use --foreground to keep it attached.\n\nOutput options:\n  --verbose, -v                     Show technical details (paths, IDs, PIDs)\n\nEnvironment options:\n  --env <local|dev|test|stage|prod>  Load .env.<env> from repo root (defaults to .env)\n  --env-file <path>                 Load a specific env file\n  PANORAMA_ENV                      Same as --env\n  PANORAMA_ENV_FILE                 Same as --env-file\n\nCLI overrides:\n  --config-dir <path>               Override config directory (default: ~/.panorama/gateway)\n  --config-path <path>              Override gateway config file\n  --log-path <path>                 Override gateway log file\n  --pid-path <path>                 Override gateway pid file\n  --claude-cli <path>               Override Claude CLI command\n  --codex-cli <path>                Override Codex CLI command\n  --gemini-cli <path>               Override Gemini CLI command\n\nEnvironment overrides:\n  PANORAMA_GATEWAY_CONFIG_DIR\n  PANORAMA_GATEWAY_CONFIG_PATH\n  PANORAMA_GATEWAY_LOG_PATH\n  PANORAMA_GATEWAY_PID_PATH\n  PANORAMA_CLAUDE_CLI or CLAUDE_CLI\n  PANORAMA_CODEX_CLI or CODEX_CLI\n  PANORAMA_GEMINI_CLI or GEMINI_CLI\n  PANORAMA_GATEWAY_AUTO_RESTART (default: on for built CLI, off for dev)\n  PANORAMA_GATEWAY_RESTART_CHECK_MS (default: 30000)\n  PANORAMA_GATEWAY_RESTART_MAX_WAIT_MS (optional)\n`);
 }
 function getStringOption(options, key) {
     const value = options[key];
@@ -116,6 +153,20 @@ function getStringOption(options, key) {
         return value;
     return undefined;
 }
+function parseBooleanInput(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on') {
+            return true;
+        }
+        if (normalized === 'false' || normalized === '0' || normalized === 'no' || normalized === 'off') {
+            return false;
+        }
+    }
+    return null;
+}
 function getActiveOptions(options) {
     return options ?? ACTIVE_OPTIONS ?? {};
 }
@@ -1110,12 +1161,44 @@ async function loadConfig(options) {
     const { configPath } = resolveGatewayPaths(options);
     await ensureOwnerOnlyFile(configPath);
     const raw = await fs.readFile(configPath, 'utf-8');
-    return JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    return {
+        ...(parsed ?? {}),
+        supabaseUrl: parsed?.supabaseUrl ?? '',
+        supabaseAnonKey: parsed?.supabaseAnonKey ?? '',
+        accessToken: parsed?.accessToken ?? '',
+        refreshToken: parsed?.refreshToken ?? '',
+        gatewayId: parsed?.gatewayId ?? '',
+        teamId: parsed?.teamId ?? '',
+        full_control_enabled: parsed?.full_control_enabled === true,
+    };
 }
 async function saveConfig(config, options) {
     const { configPath } = resolveGatewayPaths(options);
     await writeOwnerOnlyFile(configPath, JSON.stringify(config, null, 2));
 }
+async function refreshRuntimeInstallFullControl(config) {
+    const options = CURRENT_RUNTIME_OPTIONS ?? undefined;
+    try {
+        const latestConfig = await loadConfig(options);
+        const nextValue = latestConfig.full_control_enabled === true;
+        if (config.full_control_enabled !== nextValue) {
+            config.full_control_enabled = nextValue;
+            if (CURRENT_CONFIG) {
+                CURRENT_CONFIG.full_control_enabled = nextValue;
+            }
+            logInfo('Reloaded gateway install full-control setting', {
+                enabled: nextValue,
+            });
+        }
+    }
+    catch (error) {
+        logError('Failed to refresh gateway install full-control setting', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    return config.full_control_enabled === true;
+}
 function shouldEmitDebugOutput(stream) {
     if (!stream.isTTY)
         return true;
@@ -1237,6 +1320,15 @@ async function pairGateway(code, options, configResolution) {
     if (!body?.access_token || !body?.refresh_token || !body?.gateway_id || !body?.team_id) {
         throw new Error('Pairing response missing required fields');
     }
+    const requestedFullControl = parseBooleanInput(options['full-control']);
+    let existingConfig = null;
+    try {
+        existingConfig = await loadConfig(options);
+    }
+    catch {
+        existingConfig = null;
+    }
+    const installFullControlEnabled = requestedFullControl ?? existingConfig?.full_control_enabled ?? false;
     const config = {
         supabaseUrl,
         supabaseAnonKey,
@@ -1244,6 +1336,7 @@ async function pairGateway(code, options, configResolution) {
         refreshToken: body.refresh_token,
         gatewayId: body.gateway_id,
         teamId: body.team_id,
+        full_control_enabled: installFullControlEnabled,
         deviceName,
     };
     await saveConfig(config, options);
@@ -1255,6 +1348,7 @@ async function pairGateway(code, options, configResolution) {
         await discoverGatewayCliCommands(options);
         const { providerHealth: resolvedHealth, anyProviderReady: ready } = await buildCapabilities({
             validationMode: 'full',
+            installFullControlEnabled: config.full_control_enabled,
             onProgress: (event) => {
                 if (event.stage === 'start') {
                     cliInfo(`Validating ${formatProviderLabel(event.providerId)}...`, options);
@@ -1282,6 +1376,11 @@ async function pairGateway(code, options, configResolution) {
         { label: 'Gateway ID', value: body.gateway_id, verboseOnly: true },
         { label: 'Team ID', value: body.team_id, verboseOnly: true },
         { label: 'Device', value: deviceName, verboseOnly: true },
+        {
+            label: 'Install full control',
+            value: installFullControlEnabled ? 'Enabled' : 'Disabled',
+            verboseOnly: true,
+        },
         ...(providerHealthSummary
             ? [{ label: 'Provider health', value: providerHealthSummary, verboseOnly: true }]
             : []),
@@ -1567,10 +1666,12 @@ async function buildCapabilities(params) {
             return false;
         return entry.health?.status !== 'unavailable' && entry.health?.status !== 'unhealthy';
     });
+    const gatewayVersion = await getGatewayVersion();
     const runtime = {
         platform: process.platform,
         arch: process.arch,
         node_version: process.version,
+        ...(gatewayVersion ? { gateway_version: gatewayVersion } : {}),
     };
     const host = {
         kind: 'gateway',
@@ -1579,6 +1680,9 @@ async function buildCapabilities(params) {
     if (params?.deviceName) {
         host.label = params.deviceName;
     }
+    host.metadata = {
+        install_full_control_enabled: params?.installFullControlEnabled === true,
+    };
     return {
         capabilities: {
             schema_version: GATEWAY_CAPABILITIES_SCHEMA_VERSION,
@@ -1623,21 +1727,6 @@ function buildProviderFailureMessage(providerId, detail) {
     const detailSuffix = detail ? ` Details: ${detail}` : '';
     return `Gateway provider ${label} is unhealthy. Try another provider or run "panorama-gateway doctor".${detailSuffix}`;
 }
-function isProviderReady(entry) {
-    if (!entry)
-        return false;
-    if (entry.health?.status === 'healthy')
-        return true;
-    if (!entry.available)
-        return false;
-    if (!entry.health)
-        return true;
-    return entry.health.status !== 'unavailable' && entry.health.status !== 'unhealthy';
-}
-function computeGatewayStatusFromCapabilities(providers) {
-    const anyReady = Object.values(providers).some((entry) => isProviderReady(entry));
-    return anyReady ? 'ready' : 'error';
-}
 function resolveRuntimeProviderHealth(providerId) {
     if (CURRENT_PROVIDER_HEALTH && CURRENT_PROVIDER_HEALTH[providerId]) {
         return CURRENT_PROVIDER_HEALTH[providerId];
@@ -1698,7 +1787,11 @@ async function updateRuntimeProviderHealth(params) {
         ...(CURRENT_PROVIDER_HEALTH ?? {}),
         [params.providerId]: nextHealth,
     };
-    const nextStatusOverall = computeGatewayStatusFromCapabilities(providerCapabilities);
+    const nextStatusOverall = computeGatewayOperationalStatus({
+        capabilities: CURRENT_CAPABILITIES,
+        jobIngressState: CURRENT_JOB_INGRESS_STATE,
+        acceptingJobs: CURRENT_ACCEPTING_JOBS,
+    });
     if (CURRENT_CAPABILITIES && CURRENT_DEVICE_NAME) {
         await sendHeartbeat(params.supabase, nextStatusOverall, CURRENT_CAPABILITIES, CURRENT_DEVICE_NAME);
     }
@@ -1728,8 +1821,13 @@ function buildGatewayChildEnv(baseEnv) {
     const tmpDir = resolveGatewayTmpDir();
     return buildGatewayChildProcessEnv({ baseEnv, tmpDir });
 }
-function resolveChildProcessEnv(env) {
-    return buildGatewayChildEnv(env);
+function resolveChildProcessEnv(envOverrides) {
+    const tmpDir = resolveGatewayTmpDir();
+    return buildGatewayChildProcessEnv({
+        baseEnv: process.env,
+        tmpDir,
+        overrides: envOverrides,
+    });
 }
 async function runSubagentCommand(command, args, options) {
     const start = Date.now();
@@ -1781,14 +1879,11 @@ async function runSubagentCommand(command, args, options) {
         const timer = timeoutMs && Number.isFinite(timeoutMs)
             ? setTimeout(() => {
                 timedOut = true;
-                if (!child.killed) {
-                    child.kill('SIGTERM');
-                    setTimeout(() => {
-                        if (!child.killed) {
-                            child.kill('SIGKILL');
-                        }
-                    }, PROCESS_KILL_GRACE_MS);
-                }
+                requestChildTerminationWithLogging(child, {
+                    reason: 'process_timeout',
+                    graceMs: PROCESS_KILL_GRACE_MS,
+                    context: 'runSubagentCommand',
+                });
             }, timeoutMs)
             : null;
         const finalize = (exitCode, error) => {
@@ -1822,65 +1917,23 @@ async function runSubagentCommandStreaming(command, args, options) {
     const start = Date.now();
     const timeoutMs = options.timeoutMs ?? DEFAULT_SUBAGENT_TIMEOUT_MS;
     return await new Promise((resolve) => {
-        const stdoutChunks = [];
         const stderrChunks = [];
-        const events = [];
-        let stdoutBytes = 0;
         let stderrBytes = 0;
-        let stdoutTruncated = false;
         let stderrTruncated = false;
         let timedOut = false;
-        let buffer = '';
-        let sequence = 0;
+        const collector = new StreamJsonCollector({
+            maxOutputBytes: MAX_SUBAGENT_OUTPUT_BYTES,
+            maxEvents: MAX_SUBAGENT_STREAM_EVENTS,
+            maxBufferChars: MAX_SUBAGENT_STREAM_BUFFER_CHARS,
+        });
         const child = spawn(command, args, {
             cwd: options.cwd,
             env: resolveChildProcessEnv(options.env),
             stdio: ['ignore', 'pipe', 'pipe'],
         });
         options.onStart?.(child);
-        const captureStdout = (chunk) => {
-            if (stdoutBytes >= MAX_SUBAGENT_OUTPUT_BYTES) {
-                stdoutTruncated = true;
-                return;
-            }
-            const remaining = MAX_SUBAGENT_OUTPUT_BYTES - stdoutBytes;
-            if (chunk.length > remaining) {
-                stdoutChunks.push(chunk.slice(0, remaining));
-                stdoutBytes = MAX_SUBAGENT_OUTPUT_BYTES;
-                stdoutTruncated = true;
-                return;
-            }
-            stdoutChunks.push(chunk);
-            stdoutBytes += chunk.length;
-        };
-        const parseLine = (line) => {
-            const trimmed = line.trim();
-            if (!trimmed)
-                return;
-            let event = null;
-            try {
-                event = JSON.parse(trimmed);
-            }
-            catch {
-                event = null;
-            }
-            events.push({
-                sequence,
-                raw: trimmed,
-                event,
-            });
-            sequence += 1;
-        };
         child.stdout?.on('data', (chunk) => {
-            captureStdout(chunk);
-            buffer += chunk.toString('utf-8');
-            let newlineIndex = buffer.indexOf('\n');
-            while (newlineIndex >= 0) {
-                const line = buffer.slice(0, newlineIndex);
-                buffer = buffer.slice(newlineIndex + 1);
-                parseLine(line);
-                newlineIndex = buffer.indexOf('\n');
-            }
+            collector.append(chunk);
         });
         child.stderr?.on('data', (chunk) => {
             if (stderrBytes >= MAX_SUBAGENT_OUTPUT_BYTES) {
@@ -1900,36 +1953,30 @@ async function runSubagentCommandStreaming(command, args, options) {
         const timer = timeoutMs && Number.isFinite(timeoutMs)
             ? setTimeout(() => {
                 timedOut = true;
-                if (!child.killed) {
-                    child.kill('SIGTERM');
-                    setTimeout(() => {
-                        if (!child.killed) {
-                            child.kill('SIGKILL');
-                        }
-                    }, PROCESS_KILL_GRACE_MS);
-                }
+                requestChildTerminationWithLogging(child, {
+                    reason: 'process_timeout',
+                    graceMs: PROCESS_KILL_GRACE_MS,
+                    context: 'runSubagentCommandStreaming',
+                });
             }, timeoutMs)
             : null;
         const finalize = (exitCode, error) => {
             if (timer)
                 clearTimeout(timer);
-            if (buffer.trim().length > 0) {
-                parseLine(buffer);
-            }
+            const streamResult = collector.finalize();
             const durationMs = Date.now() - start;
-            const stdout = Buffer.concat(stdoutChunks).toString('utf-8');
             const stderr = Buffer.concat(stderrChunks).toString('utf-8');
             const ok = !timedOut && exitCode === 0 && !error;
             resolve({
                 ok,
-                stdout,
+                stdout: streamResult.stdout,
                 stderr,
                 exitCode,
                 durationMs,
                 timedOut,
-                stdoutTruncated,
+                stdoutTruncated: streamResult.stdoutTruncated || streamResult.eventsTruncated,
                 stderrTruncated,
-                events,
+                events: streamResult.events,
                 error,
             });
         };
@@ -2166,6 +2213,11 @@ function describeGatewayJob(job) {
     if (job.job_type === 'subagent_cancel') {
         return { job_kind: 'subagent_cancel' };
     }
+    if (job.job_type === 'shell_session') {
+        const payload = job.payload ?? {};
+        const action = typeof payload.action === 'string' ? payload.action : null;
+        return { job_kind: 'shell_session', shell_action: action };
+    }
     return { job_kind: job.job_type };
 }
 function inferProviderFromSubagentType(subagentType) {
@@ -2224,15 +2276,86 @@ function classifySubagentRetryable(params) {
     return null;
 }
 async function getNextRunSequence(supabase, subagentId) {
-    const { data } = await supabase
-        .from('subagent_runs')
-        .select('run_sequence')
-        .eq('subagent_id', subagentId)
-        .order('run_sequence', { ascending: false })
+    const { data, error } = await supabase.rpc('allocate_subagent_run_sequence', {
+        p_subagent_id: subagentId,
+    });
+    if (error) {
+        logError('Failed to allocate subagent run sequence; falling back to read-based sequence', {
+            subagentId,
+            error: error.message,
+        });
+        const { data: fallback } = await supabase
+            .from('subagent_runs')
+            .select('run_sequence')
+            .eq('subagent_id', subagentId)
+            .order('run_sequence', { ascending: false })
+            .limit(1)
+            .maybeSingle();
+        const lastSequence = fallback && typeof fallback.run_sequence === 'number' ? fallback.run_sequence : 0;
+        return lastSequence + 1;
+    }
+    return typeof data === 'number' && Number.isFinite(data) ? data : 1;
+}
+async function getNextSubagentRunEventSequence(supabase, runId) {
+    const { data, error } = await supabase
+        .from('subagent_run_events')
+        .select('sequence')
+        .eq('run_id', runId)
+        .order('sequence', { ascending: false })
         .limit(1)
         .maybeSingle();
-    const lastSequence = data && typeof data.run_sequence === 'number' ? data.run_sequence : 0;
-    return lastSequence + 1;
+    if (error) {
+        logError('Failed to fetch subagent run event sequence; defaulting to 0', {
+            runId,
+            error: error.message,
+        });
+        return 0;
+    }
+    if (!data || typeof data.sequence !== 'number' || !Number.isFinite(data.sequence)) {
+        return 0;
+    }
+    return data.sequence + 1;
+}
+function normalizeSubagentRunEventType(value, fallback = 'system') {
+    if (typeof value !== 'string')
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    return SUBAGENT_RUN_EVENT_TYPE_SET.has(normalized) ? normalized : fallback;
+}
+async function insertSubagentRunEvent(params) {
+    const normalizedType = normalizeSubagentRunEventType(params.eventType, 'system');
+    const insertWithSequence = async (sequence) => params.supabase.from('subagent_run_events').insert({
+        run_id: params.runId,
+        subagent_id: params.subagentId,
+        team_id: params.teamId,
+        gateway_id: params.gatewayId,
+        sequence,
+        event_type: normalizedType,
+        payload: asJson(trimEventPayload(params.payload)),
+    });
+    const { error } = await insertWithSequence(params.sequence);
+    if (!error)
+        return params.sequence;
+    if (error.code === '23505') {
+        const retrySequence = await getNextSubagentRunEventSequence(params.supabase, params.runId);
+        const { error: retryError } = await insertWithSequence(retrySequence);
+        if (!retryError)
+            return retrySequence;
+        logError('Failed to insert subagent run event after retry', {
+            runId: params.runId,
+            subagentId: params.subagentId,
+            event_type: normalizedType,
+            error: retryError.message,
+        });
+        return null;
+    }
+    logError('Failed to insert subagent run event', {
+        runId: params.runId,
+        subagentId: params.subagentId,
+        event_type: normalizedType,
+        error: error.message,
+    });
+    return null;
 }
 function mergeMetadata(base, update) {
     return {
@@ -2243,19 +2366,61 @@ function mergeMetadata(base, update) {
 function asJson(value) {
     return value;
 }
+async function loadGatewayControlState(supabase, config) {
+    const { data, error } = await supabase
+        .from('team_gateways')
+        .select('full_control_enabled, status, last_seen_at')
+        .eq('id', config.gatewayId)
+        .eq('team_id', config.teamId)
+        .maybeSingle();
+    if (error) {
+        logError('Failed to load gateway control state', {
+            gatewayId: config.gatewayId,
+            teamId: config.teamId,
+            error: error.message,
+        });
+        return null;
+    }
+    if (!data)
+        return null;
+    return {
+        full_control_enabled: data.full_control_enabled === true,
+        status: typeof data.status === 'string' ? data.status : 'unknown',
+        last_seen_at: typeof data.last_seen_at === 'string' ? data.last_seen_at : null,
+    };
+}
+function isHeartbeatFresh(lastSeenAt) {
+    if (!lastSeenAt)
+        return false;
+    const parsed = Date.parse(lastSeenAt);
+    if (!Number.isFinite(parsed))
+        return false;
+    return Date.now() - parsed <= GATEWAY_HEARTBEAT_STALE_MS;
+}
+function requestChildTerminationWithLogging(child, options) {
+    terminateChildProcess(child, {
+        reason: options.reason,
+        graceMs: options.graceMs,
+        onError: (phase, error) => {
+            logError('Failed to send child process termination signal', {
+                context: options.context,
+                reason: options.reason,
+                phase,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        },
+    });
+}
 function requestSubagentCancel(subagentId, runId, reason) {
     const activeRun = activeSubagentRuns.get(subagentId);
     if (activeRun && (!runId || activeRun.runId === runId)) {
         activeRun.cancelled = true;
         activeRun.cancelReason = reason;
-        if (activeRun.child) {
-            activeRun.child.kill('SIGTERM');
-            setTimeout(() => {
-                if (!activeRun.child?.killed) {
-                    activeRun.child?.kill('SIGKILL');
-                }
-            }, SUBAGENT_CANCEL_KILL_TIMEOUT_MS);
-        }
+        requestChildTerminationWithLogging(activeRun.child, {
+            reason,
+            graceMs: SUBAGENT_CANCEL_KILL_TIMEOUT_MS,
+            context: 'gateway_cancel_request',
+        });
         return { active: true };
     }
     if (runId) {
@@ -2273,6 +2438,9 @@ function resolvePendingCancel(subagentId, runId, metadata) {
             ? metadata.cancel_reason
             : 'Cancelled';
     }
+    return resolvePendingCancelFromQueue(subagentId, runId);
+}
+function resolvePendingCancelFromQueue(subagentId, runId) {
     const pendingByRun = pendingCancelByRunId.get(runId);
     if (pendingByRun)
         return pendingByRun.reason;
@@ -2281,6 +2449,13 @@ function resolvePendingCancel(subagentId, runId, metadata) {
         return pendingBySubagent.reason;
     return null;
 }
+function consumePendingCancelFromQueue(subagentId, runId) {
+    const reason = resolvePendingCancelFromQueue(subagentId, runId);
+    if (!reason)
+        return null;
+    clearPendingCancel(subagentId, runId);
+    return reason;
+}
 function clearPendingCancel(subagentId, runId) {
     pendingCancelByRunId.delete(runId);
     pendingCancelBySubagentId.delete(subagentId);
@@ -2294,7 +2469,17 @@ function buildErrorOutput(message) {
     };
 }
 function isJobTargeted(job, gatewayId) {
-    return !job.gateway_id || job.gateway_id === gatewayId;
+    return job.gateway_id === gatewayId;
+}
+function resolveJobSubagentId(job) {
+    if (job.job_type !== 'subagent_run')
+        return null;
+    const payload = job.payload ?? {};
+    return typeof payload.subagent_id === 'string'
+        ? payload.subagent_id
+        : typeof payload.subagentId === 'string'
+            ? payload.subagentId
+            : null;
 }
 async function sendHeartbeat(supabase, status, capabilities, deviceName) {
     const { error } = await supabase.functions.invoke('gateway-heartbeat', {
@@ -2322,7 +2507,7 @@ async function claimJob(supabase, config, job) {
         .eq('id', job.id)
         .eq('team_id', config.teamId)
         .eq('status', 'queued')
-        .or(`gateway_id.is.null,gateway_id.eq.${config.gatewayId}`)
+        .eq('gateway_id', config.gatewayId)
         .select('*')
         .maybeSingle();
     if (error) {
@@ -2410,7 +2595,7 @@ async function handleDiagnosticJob() {
         },
     };
 }
-async function handleSubagentCancelJob(supabase, job) {
+async function handleSubagentCancelJob(supabase, config, job) {
     const payload = job.payload ?? {};
     const subagentId = typeof payload.subagent_id === 'string'
         ? payload.subagent_id
@@ -2432,12 +2617,35 @@ async function handleSubagentCancelJob(supabase, job) {
     const reason = typeof payload.reason === 'string' && payload.reason.trim().length > 0
         ? payload.reason.trim()
         : 'Cancelled';
-    const { data: subagent } = await supabase
+    const { data: subagent, error: subagentError } = await supabase
         .from('subagents')
-        .select('status, metadata, input')
+        .select('id, team_id, gateway_id, subagent_type, status, metadata')
         .eq('id', subagentId)
         .maybeSingle();
-    if (!subagent || subagent.status !== 'running') {
+    if (subagentError) {
+        return {
+            ok: false,
+            result: { message: 'Failed to load subagent for cancellation', subagent_id: subagentId },
+            error: subagentError.message,
+        };
+    }
+    if (!subagent) {
+        return {
+            ok: true,
+            result: {
+                subagent_id: subagentId,
+                run_id: runId,
+                cancelled_active_run: false,
+                reason,
+                cancel_result: 'no_active_run',
+                cancel_state: 'none',
+                cancel_supported: false,
+                status: 'not_found',
+                message: 'Subagent not found; no active run to cancel.',
+            },
+        };
+    }
+    if (subagent.gateway_id !== config.gatewayId) {
         return {
             ok: true,
             result: {
@@ -2445,72 +2653,216 @@ async function handleSubagentCancelJob(supabase, job) {
                 run_id: runId,
                 cancelled_active_run: false,
                 reason,
-                message: 'Subagent not running',
+                cancel_result: 'no_active_run',
+                cancel_state: 'none',
+                cancel_supported: false,
+                status: 'running',
+                message: 'Subagent is assigned to another gateway; skipping stale cancel request.',
             },
         };
     }
     const metadata = (subagent.metadata ?? {});
-    const input = (subagent.input ?? {});
-    const resolvedRunId = runId ||
-        (typeof metadata.current_run_id === 'string' ? metadata.current_run_id : null) ||
-        (typeof input.run_id === 'string' ? input.run_id : null);
-    const { active } = requestSubagentCancel(subagentId, resolvedRunId, reason);
-    if (resolvedRunId) {
-        const nowIso = new Date().toISOString();
-        const cancelledOutput = buildErrorOutput(reason);
+    const status = typeof subagent.status === 'string' ? subagent.status : 'unknown';
+    const hasGateway = !!subagent.gateway_id;
+    const cancelAdapter = getSubagentCancelAdapter(subagent.subagent_type);
+    const cancelSupported = cancelAdapter.supported &&
+        (cancelAdapter.support !== 'gateway' || hasGateway);
+    const cancelSupportMode = cancelAdapter.support;
+    const cancellationScope = cancelAdapter.scope;
+    let activeRun = null;
+    if (status === 'running') {
         const { data: runningRun, error: runningRunError } = await supabase
             .from('subagent_runs')
-            .select('id, status')
-            .eq('id', resolvedRunId)
+            .select('id, metadata')
+            .eq('subagent_id', subagentId)
             .eq('status', 'running')
+            .order('run_sequence', { ascending: false })
+            .limit(1)
             .maybeSingle();
         if (runningRunError) {
-            logError('Failed to fetch running subagent run for cancel', {
+            return {
+                ok: false,
+                result: {
+                    message: 'Failed to resolve active subagent run for cancellation',
+                    subagent_id: subagentId,
+                },
                 error: runningRunError.message,
-                subagentId,
-                runId: resolvedRunId,
-            });
+            };
+        }
+        activeRun = runningRun;
+    }
+    const resolution = resolveCancelRequest({
+        subagent_status: status,
+        requested_run_id: runId,
+        active_run_id: activeRun?.id ?? null,
+        cancel_supported: cancelSupported,
+    });
+    if (!resolution.accepted) {
+        return {
+            ok: true,
+            result: {
+                subagent_id: subagentId,
+                run_id: resolution.resolved_run_id,
+                active_run_id: activeRun?.id ?? null,
+                cancelled_active_run: false,
+                reason,
+                cancel_result: resolution.cancel_result,
+                cancel_state: resolution.cancel_state,
+                cancel_supported: cancelSupported,
+                status: resolution.status,
+                message: resolution.message,
+            },
+        };
+    }
+    const resolvedRunId = resolution.resolved_run_id;
+    if (!resolvedRunId) {
+        return {
+            ok: false,
+            result: {
+                message: 'Cancel accepted without an active run_id',
+                subagent_id: subagentId,
+            },
+            error: 'Cancel accepted without an active run_id',
+        };
+    }
+    const nowIso = new Date().toISOString();
+    const mergedMetadata = buildRequestedCancelMetadata({
+        base: metadata,
+        run_id: resolvedRunId,
+        reason,
+        requested_at: nowIso,
+        cancel_support: cancelSupportMode,
+        cancellation_scope: cancellationScope,
+    });
+    const { data: updatedSubagent, error: subagentUpdateError } = await supabase
+        .from('subagents')
+        .update({
+        metadata: asJson(mergedMetadata),
+    })
+        .eq('status', 'running')
+        .eq('id', subagentId)
+        .select('id')
+        .maybeSingle();
+    if (subagentUpdateError) {
+        return {
+            ok: false,
+            result: {
+                message: 'Failed to persist subagent cancellation metadata',
+                subagent_id: subagentId,
+                run_id: resolvedRunId,
+            },
+            error: subagentUpdateError.message,
+        };
+    }
+    if (!updatedSubagent) {
+        const { data: latestSubagent, error: latestSubagentError } = await supabase
+            .from('subagents')
+            .select('status')
+            .eq('id', subagentId)
+            .maybeSingle();
+        if (latestSubagentError) {
+            return {
+                ok: false,
+                result: {
+                    message: 'Failed to refresh subagent status after cancel race',
+                    subagent_id: subagentId,
+                    run_id: resolvedRunId,
+                },
+                error: latestSubagentError.message,
+            };
         }
-        if (runningRun?.id) {
-            const { error: runUpdateError } = await supabase
+        const latestStatus = typeof latestSubagent?.status === 'string' ? latestSubagent.status : status;
+        let latestActiveRunId = null;
+        if (latestStatus === 'running') {
+            const { data: latestRunningRun, error: latestRunningRunError } = await supabase
                 .from('subagent_runs')
-                .update({
-                status: 'cancelled',
-                output: asJson(cancelledOutput),
-                error: reason,
-                completed_at: nowIso,
-            })
-                .eq('id', resolvedRunId);
-            if (runUpdateError) {
-                logError('Failed to mark subagent run as cancelled', {
-                    error: runUpdateError.message,
-                    subagentId,
-                    runId: resolvedRunId,
-                });
-            }
-            const { error: subagentUpdateError } = await supabase
-                .from('subagents')
-                .update({
-                status: 'failed',
-                output: asJson(cancelledOutput),
-                error: reason,
-                completed_at: nowIso,
-                metadata: asJson(mergeMetadata(metadata, {
-                    cancel_run_id: resolvedRunId,
-                    cancel_requested_at: nowIso,
-                    cancel_reason: reason,
-                })),
-            })
-                .eq('id', subagentId);
-            if (subagentUpdateError) {
-                logError('Failed to mark subagent as cancelled', {
-                    error: subagentUpdateError.message,
-                    subagentId,
-                    runId: resolvedRunId,
-                });
+                .select('id')
+                .eq('subagent_id', subagentId)
+                .eq('status', 'running')
+                .order('run_sequence', { ascending: false })
+                .limit(1)
+                .maybeSingle();
+            if (latestRunningRunError) {
+                return {
+                    ok: false,
+                    result: {
+                        message: 'Failed to refresh active subagent run after cancel race',
+                        subagent_id: subagentId,
+                        run_id: resolvedRunId,
+                    },
+                    error: latestRunningRunError.message,
+                };
             }
+            latestActiveRunId = latestRunningRun?.id ?? null;
+        }
+        const latestResolution = resolveCancelRequest({
+            subagent_status: latestStatus,
+            requested_run_id: runId,
+            active_run_id: latestActiveRunId,
+            cancel_supported: cancelSupported,
+        });
+        return {
+            ok: true,
+            result: {
+                subagent_id: subagentId,
+                run_id: latestResolution.resolved_run_id,
+                cancelled_active_run: false,
+                reason,
+                cancel_result: latestResolution.cancel_result,
+                cancel_state: latestResolution.cancel_state,
+                cancel_supported: cancelSupported,
+                status: latestResolution.status,
+                message: latestResolution.message,
+            },
+        };
+    }
+    if (activeRun) {
+        const runMetadata = (activeRun.metadata ?? {});
+        const { error: runUpdateError } = await supabase
+            .from('subagent_runs')
+            .update({
+            metadata: asJson(buildRequestedCancelMetadata({
+                base: runMetadata,
+                run_id: resolvedRunId,
+                reason,
+                requested_at: nowIso,
+                cancel_support: cancelSupportMode,
+                cancellation_scope: cancellationScope,
+            })),
+        })
+            .eq('id', resolvedRunId)
+            .eq('status', 'running');
+        if (runUpdateError) {
+            return {
+                ok: false,
+                result: {
+                    message: 'Failed to persist run cancellation metadata',
+                    subagent_id: subagentId,
+                    run_id: resolvedRunId,
+                },
+                error: runUpdateError.message,
+            };
         }
     }
+    const { active } = requestSubagentCancel(subagentId, resolvedRunId, reason);
+    if (activeRun) {
+        const nextEventSequence = await getNextSubagentRunEventSequence(supabase, resolvedRunId);
+        await insertSubagentRunEvent({
+            supabase,
+            runId: resolvedRunId,
+            subagentId,
+            teamId: subagent.team_id,
+            gatewayId: subagent.gateway_id,
+            sequence: nextEventSequence,
+            eventType: 'cancellation_requested',
+            payload: {
+                reason,
+                source: 'gateway_cancel_job',
+                active_process: active,
+                cancel_state: 'requested',
+            },
+        });
+    }
     return {
         ok: true,
         result: {
@@ -2518,10 +2870,17 @@ async function handleSubagentCancelJob(supabase, job) {
             run_id: resolvedRunId,
             cancelled_active_run: active,
             reason,
+            cancel_result: 'accepted',
+            cancel_state: 'requested',
+            cancel_supported: cancelSupported,
+            status: resolution.status,
+            message: cancelSupportMode === 'gateway'
+                ? 'Cancel requested and forwarded to gateway.'
+                : 'Cancel requested. Worker will stop the run on its next cancellation check.',
         },
     };
 }
-async function handleSubagentRunJob(supabase, job) {
+async function handleSubagentRunJob(supabase, config, job) {
     const payload = job.payload ?? {};
     const subagentId = typeof payload.subagent_id === 'string'
         ? payload.subagent_id
@@ -2544,9 +2903,26 @@ async function handleSubagentRunJob(supabase, job) {
         return {
             ok: false,
             result: { message: 'Subagent not found', subagent_id: subagentId },
+            jobStatus: 'cancelled',
+            skipSubagentFailure: true,
             error: subagentError?.message ?? 'Subagent not found',
         };
     }
+    if (subagent.gateway_id !== config.gatewayId) {
+        const message = 'Subagent is assigned to a different gateway';
+        return {
+            ok: false,
+            result: {
+                message,
+                subagent_id: subagentId,
+                assigned_gateway_id: subagent.gateway_id,
+                gateway_id: config.gatewayId,
+            },
+            jobStatus: 'cancelled',
+            skipSubagentFailure: true,
+            error: message,
+        };
+    }
     const subagentType = subagent.subagent_type;
     const adapter = getSubagentAdapter(subagentType);
     if (!adapter) {
@@ -2572,6 +2948,59 @@ async function handleSubagentRunJob(supabase, job) {
     }
     const configPayload = (subagent.config ?? {});
     const metadata = (subagent.metadata ?? {});
+    const subagentFullControlRequested = parseBooleanInput(configPayload.full_control) ??
+        parseBooleanInput(configPayload.fullControl) ??
+        false;
+    const installFullControlEnabled = await refreshRuntimeInstallFullControl(config);
+    const gatewayControlState = await loadGatewayControlState(supabase, config);
+    if (!gatewayControlState) {
+        return {
+            ok: false,
+            result: { message: 'Gateway control state unavailable', subagent_id: subagentId },
+            error: 'Gateway control state unavailable',
+        };
+    }
+    const gatewayHeartbeatFresh = gatewayControlState.status === 'ready' &&
+        isHeartbeatFresh(gatewayControlState.last_seen_at);
+    if (!gatewayHeartbeatFresh) {
+        return {
+            ok: false,
+            result: {
+                message: 'Gateway is offline or heartbeat is stale',
+                subagent_id: subagentId,
+            },
+            error: 'Gateway is offline or heartbeat is stale',
+        };
+    }
+    const adapterId = adapter.id;
+    const providerSupport = PROVIDER_CAPABILITIES?.[adapterId]?.supported_flags ??
+        (adapterId === 'claude_code'
+            ? toFlagRecord(CLAUDE_SUPPORT ?? DEFAULT_CLAUDE_SUPPORT)
+            : {});
+    const providerFullControlSupport = evaluateGatewayProviderFullControlSupport(adapterId, providerSupport);
+    const layeredFullControlEnabled = installFullControlEnabled && gatewayControlState.full_control_enabled;
+    const effectiveFullControl = subagentFullControlRequested &&
+        layeredFullControlEnabled &&
+        providerFullControlSupport.supported;
+    let fullControlDeniedReason = null;
+    if (subagentFullControlRequested && !effectiveFullControl) {
+        fullControlDeniedReason = !installFullControlEnabled
+            ? 'Gateway install full control is disabled. Run "panorama-gateway full-control enable" on the host.'
+            : !gatewayControlState.full_control_enabled
+                ? 'Gateway connection full control is disabled by team settings.'
+                : providerFullControlSupport.reason ?? 'Gateway provider full control is unavailable.';
+    }
+    logInfo('Resolved subagent full-control state', {
+        jobId: job.id,
+        subagentId,
+        providerId: adapterId,
+        fullControlRequested: subagentFullControlRequested,
+        installFullControlEnabled,
+        gatewayFullControlEnabled: gatewayControlState.full_control_enabled,
+        providerFullControlSupported: providerFullControlSupport.supported,
+        fullControlDeniedReason,
+        fullControlEffective: effectiveFullControl,
+    });
     const inputPayload = (subagent.input ?? {});
     const inputRunId = typeof inputPayload.run_id === 'string' ? inputPayload.run_id.trim() : null;
     const rawRunSequence = typeof inputPayload.run_sequence === 'number'
@@ -2608,10 +3037,33 @@ async function handleSubagentRunJob(supabase, job) {
     const runMetadata = {
         schema_version: SUBAGENT_SCHEMA_VERSION,
         runner: 'gateway',
-        adapter_id: adapter.id,
+        adapter_id: adapterId,
         subagent_type: subagentType,
         run_id: resolvedRunId,
         run_sequence: runSequence,
+        cancel_state: 'none',
+        full_control_requested: subagentFullControlRequested,
+        full_control_effective: effectiveFullControl,
+        full_control_denied_reason: fullControlDeniedReason,
+    };
+    let nextEventSequence = null;
+    const emitRunEvent = async (eventType, eventPayload) => {
+        if (nextEventSequence == null) {
+            nextEventSequence = await getNextSubagentRunEventSequence(supabase, resolvedRunId);
+        }
+        const insertedSequence = await insertSubagentRunEvent({
+            supabase,
+            runId: resolvedRunId,
+            subagentId,
+            teamId: subagent.team_id,
+            gatewayId: subagent.gateway_id,
+            sequence: nextEventSequence,
+            eventType,
+            payload: eventPayload,
+        });
+        if (typeof insertedSequence === 'number') {
+            nextEventSequence = insertedSequence + 1;
+        }
     };
     const pendingCancelReason = resolvePendingCancel(subagentId, resolvedRunId, metadata);
     if (pendingCancelReason) {
@@ -2633,6 +3085,10 @@ async function handleSubagentRunJob(supabase, job) {
             metadata: asJson({
                 ...runMetadata,
                 cancel_reason: pendingCancelReason,
+                cancel_support: 'gateway',
+                cancel_state: 'acknowledged',
+                cancellation_scope: 'gateway',
+                cancelled: true,
             }),
         });
         if (cancelInsertError) {
@@ -2642,6 +3098,21 @@ async function handleSubagentRunJob(supabase, job) {
                 error: cancelInsertError.message,
             };
         }
+        await emitRunEvent('cancellation_requested', {
+            reason: pendingCancelReason,
+            source: 'pending_cancel',
+            stage: 'before_start',
+        });
+        await emitRunEvent('cancellation_acknowledged', {
+            reason: pendingCancelReason,
+            source: 'gateway',
+            cancellation_scope: 'gateway',
+        });
+        await emitRunEvent('run_cancelled', {
+            reason: pendingCancelReason,
+            source: 'gateway',
+            cancellation_scope: 'gateway',
+        });
         return {
             ok: true,
             result: {
@@ -2664,6 +3135,41 @@ async function handleSubagentRunJob(supabase, job) {
         metadata: asJson(runMetadata),
     });
     if (runInsertError) {
+        if (runInsertError.code === '23505') {
+            const { data: existingRunningRun, error: existingRunningRunError } = await supabase
+                .from('subagent_runs')
+                .select('id, status')
+                .eq('subagent_id', subagentId)
+                .eq('status', 'running')
+                .order('run_sequence', { ascending: false })
+                .limit(1)
+                .maybeSingle();
+            if (existingRunningRunError) {
+                return {
+                    ok: false,
+                    result: {
+                        message: 'Failed to resolve conflicting subagent run after insert conflict',
+                        subagent_id: subagentId,
+                        run_id: resolvedRunId,
+                    },
+                    error: existingRunningRunError.message,
+                };
+            }
+            if (existingRunningRun?.id && existingRunningRun.id !== resolvedRunId) {
+                return {
+                    ok: false,
+                    result: {
+                        message: 'Skipped duplicate subagent job because another run is already active',
+                        subagent_id: subagentId,
+                        run_id: resolvedRunId,
+                        active_run_id: existingRunningRun.id,
+                    },
+                    jobStatus: 'cancelled',
+                    skipSubagentFailure: true,
+                    error: 'Another subagent run is already active',
+                };
+            }
+        }
         return {
             ok: false,
             result: { message: 'Failed to create subagent run', subagent_id: subagentId },
@@ -2675,7 +3181,12 @@ async function handleSubagentRunJob(supabase, job) {
         cancelled: false,
     };
     activeSubagentRuns.set(subagentId, activeRun);
-    await supabase
+    const latePendingCancelReason = consumePendingCancelFromQueue(subagentId, resolvedRunId);
+    if (latePendingCancelReason) {
+        activeRun.cancelled = true;
+        activeRun.cancelReason = latePendingCancelReason;
+    }
+    const { error: startSubagentUpdateError } = await supabase
         .from('subagents')
         .update({
         status: 'running',
@@ -2686,41 +3197,94 @@ async function handleSubagentRunJob(supabase, job) {
         })),
     })
         .eq('id', subagentId);
-    const failRun = async (message) => {
+    if (startSubagentUpdateError) {
+        activeSubagentRuns.delete(subagentId);
+        return {
+            ok: false,
+            result: {
+                message: 'Failed to mark subagent as running',
+                subagent_id: subagentId,
+                run_id: resolvedRunId,
+            },
+            error: startSubagentUpdateError.message,
+        };
+    }
+    await emitRunEvent('run_started', {
+        runner: 'gateway',
+        adapter_id: adapterId,
+        subagent_type: subagentType,
+        run_id: resolvedRunId,
+        run_sequence: runSequence,
+    });
+    const failRun = async (message, options) => {
         const failureOutput = buildErrorOutput(message);
         const completedAt = new Date().toISOString();
-        await supabase
+        const metadataUpdate = mergeMetadata(runMetadata, options?.metadata ?? {});
+        const { error: runFailureUpdateError } = await supabase
             .from('subagent_runs')
             .update({
             status: 'failed',
             output: asJson(failureOutput),
             error: message,
             completed_at: completedAt,
+            metadata: asJson(metadataUpdate),
         })
             .eq('id', resolvedRunId);
-        await supabase
+        if (runFailureUpdateError) {
+            logError('Failed to persist failed subagent run state', {
+                subagentId,
+                runId: resolvedRunId,
+                error: runFailureUpdateError.message,
+            });
+        }
+        const { error: subagentFailureUpdateError } = await supabase
             .from('subagents')
             .update({
             status: 'failed',
             output: asJson(failureOutput),
             error: message,
             completed_at: completedAt,
+            metadata: asJson(mergeMetadata(metadata, options?.metadata ?? {})),
         })
             .eq('id', subagentId);
+        if (subagentFailureUpdateError) {
+            logError('Failed to persist failed subagent state', {
+                subagentId,
+                runId: resolvedRunId,
+                error: subagentFailureUpdateError.message,
+            });
+        }
+        await emitRunEvent('run_failed', {
+            reason: message,
+            source: 'gateway',
+            stage: 'pre_execution',
+        });
         activeSubagentRuns.delete(subagentId);
+        const persistenceErrors = [
+            runFailureUpdateError ? `run update: ${runFailureUpdateError.message}` : null,
+            subagentFailureUpdateError ? `subagent update: ${subagentFailureUpdateError.message}` : null,
+        ].filter((value) => !!value);
+        const error = persistenceErrors.length > 0
+            ? `${message} (persistence errors: ${persistenceErrors.join('; ')})`
+            : message;
         return {
             ok: false,
             result: { message, subagent_id: subagentId },
-            error: message,
+            error,
         };
     };
+    if (subagentFullControlRequested && !effectiveFullControl) {
+        const deniedReason = fullControlDeniedReason ?? 'Gateway full control is unavailable.';
+        return await failRun(deniedReason, {
+            metadata: {
+                full_control_requested: true,
+                full_control_effective: false,
+                full_control_denied_reason: deniedReason,
+            },
+        });
+    }
     let runPlan;
     try {
-        const adapterId = adapter.id;
-        const providerSupport = PROVIDER_CAPABILITIES?.[adapterId]?.supported_flags ??
-            (adapterId === 'claude_code'
-                ? toFlagRecord(CLAUDE_SUPPORT ?? DEFAULT_CLAUDE_SUPPORT)
-                : {});
         const command = adapterId === 'codex'
             ? resolveCodexCommand()
             : adapterId === 'gemini'
@@ -2731,6 +3295,7 @@ async function handleSubagentRunJob(supabase, job) {
             config: configPayload,
             command,
             support: providerSupport,
+            fullControl: effectiveFullControl,
             resumeSessionId,
         });
     }
@@ -2764,6 +3329,11 @@ async function handleSubagentRunJob(supabase, job) {
             activeResult = null;
             normalized = null;
             let executionError = null;
+            await emitRunEvent('run_progress', {
+                phase: 'attempt_started',
+                attempt,
+                max_attempts: retryConfig.maxAttempts,
+            });
             try {
                 if (runPlan.outputFormat === 'stream-json') {
                     streamResult = await runSubagentCommandStreaming(runPlan.command, runPlan.args, {
@@ -2773,12 +3343,11 @@ async function handleSubagentRunJob(supabase, job) {
                         onStart: (child) => {
                             activeRun.child = child;
                             if (activeRun.cancelled) {
-                                child.kill('SIGTERM');
-                                setTimeout(() => {
-                                    if (!child.killed) {
-                                        child.kill('SIGKILL');
-                                    }
-                                }, SUBAGENT_CANCEL_KILL_TIMEOUT_MS);
+                                requestChildTerminationWithLogging(child, {
+                                    reason: activeRun.cancelReason ?? 'Cancelled',
+                                    graceMs: SUBAGENT_CANCEL_KILL_TIMEOUT_MS,
+                                    context: 'subagent_run_streaming_on_start',
+                                });
                             }
                         },
                     });
@@ -2791,12 +3360,11 @@ async function handleSubagentRunJob(supabase, job) {
                         onStart: (child) => {
                             activeRun.child = child;
                             if (activeRun.cancelled) {
-                                child.kill('SIGTERM');
-                                setTimeout(() => {
-                                    if (!child.killed) {
-                                        child.kill('SIGKILL');
-                                    }
-                                }, SUBAGENT_CANCEL_KILL_TIMEOUT_MS);
+                                requestChildTerminationWithLogging(child, {
+                                    reason: activeRun.cancelReason ?? 'Cancelled',
+                                    graceMs: SUBAGENT_CANCEL_KILL_TIMEOUT_MS,
+                                    context: 'subagent_run_on_start',
+                                });
                             }
                         },
                     });
@@ -2866,6 +3434,13 @@ async function handleSubagentRunJob(supabase, job) {
                     reason: retryDecision.reason,
                     delay_ms: delayMs,
                 });
+                await emitRunEvent('run_progress', {
+                    phase: 'retry_scheduled',
+                    attempt,
+                    max_attempts: retryConfig.maxAttempts,
+                    reason: retryDecision.reason,
+                    delay_ms: delayMs,
+                });
                 await sleep(delayMs);
                 continue;
             }
@@ -2898,6 +3473,7 @@ async function handleSubagentRunJob(supabase, job) {
         const completedAt = new Date().toISOString();
         const parseStrict = runPlan.outputFormat === 'json';
         const shouldFail = !activeResult.ok || (parseStrict && !!parseError);
+        const effectiveShouldFail = !wasCancelled && shouldFail;
         const stderrMessage = activeResult.stderr && activeResult.stderr.trim().length > 0
             ? activeResult.stderr.trim()
             : null;
@@ -2909,7 +3485,7 @@ async function handleSubagentRunJob(supabase, job) {
             : parseError ?? null;
         const providerId = adapter.id;
         if (!wasCancelled) {
-            if (shouldFail) {
+            if (effectiveShouldFail) {
                 const stderrInfo = truncateLog(activeResult.stderr ?? '');
                 const stdoutInfo = truncateLog(activeResult.stdout ?? '');
                 logError('Subagent run failed', {
@@ -2954,6 +3530,9 @@ async function handleSubagentRunJob(supabase, job) {
             }
         }
         const failureOutput = buildErrorOutput(wasCancelled ? cancelReason : errorMessage ?? 'Subagent run failed');
+        const finalStatus = wasCancelled ? 'cancelled' : effectiveShouldFail ? 'failed' : 'completed';
+        const finalOutput = wasCancelled || effectiveShouldFail ? failureOutput : output;
+        const finalError = wasCancelled ? cancelReason : effectiveShouldFail ? errorMessage : null;
         const metadataUpdate = {
             schema_version: SUBAGENT_SCHEMA_VERSION,
             runner: 'gateway',
@@ -2977,6 +3556,12 @@ async function handleSubagentRunJob(supabase, job) {
             cancel_requested_at: null,
             cancel_reason: wasCancelled ? cancelReason : null,
             cancelled: wasCancelled,
+            cancel_state: wasCancelled ? 'acknowledged' : 'none',
+            cancel_support: wasCancelled ? 'gateway' : null,
+            cancellation_scope: wasCancelled ? 'gateway' : null,
+            full_control_requested: subagentFullControlRequested,
+            full_control_effective: effectiveFullControl,
+            full_control_denied_reason: null,
         };
         if (activeResult.stderr) {
             metadataUpdate.stderr = activeResult.stderr;
@@ -2985,69 +3570,95 @@ async function handleSubagentRunJob(supabase, job) {
         const runMetadataUpdate = mergeMetadata(mergeMetadata(runMetadata, normalized.metadata), metadataUpdate);
         if (streamResult?.events?.length && adapter.normalizeStreamEvents) {
             const normalizedEvents = adapter.normalizeStreamEvents(streamResult.events);
-            const eventRows = normalizedEvents.map((entry, index) => ({
-                run_id: resolvedRunId,
-                subagent_id: subagentId,
-                team_id: subagent.team_id,
-                gateway_id: subagent.gateway_id,
-                sequence: index,
-                event_type: entry.event_type,
-                payload: asJson(trimEventPayload(entry.payload)),
-            }));
-            for (let i = 0; i < eventRows.length; i += SUBAGENT_EVENT_BATCH_SIZE) {
-                const chunk = eventRows.slice(i, i + SUBAGENT_EVENT_BATCH_SIZE);
-                const { error: eventsError } = await supabase
-                    .from('subagent_run_events')
-                    .insert(chunk);
-                if (eventsError) {
-                    logError('Failed to insert subagent run events', {
-                        error: eventsError.message,
-                        subagentId,
-                        runId: resolvedRunId,
-                    });
-                }
+            for (const entry of normalizedEvents) {
+                await emitRunEvent(entry.event_type, entry.payload);
             }
         }
-        await supabase
+        if (wasCancelled) {
+            await emitRunEvent('cancellation_acknowledged', {
+                reason: cancelReason,
+                source: 'gateway',
+                cancellation_scope: 'gateway',
+            });
+            await emitRunEvent('run_cancelled', {
+                reason: cancelReason,
+                source: 'gateway',
+                cancellation_scope: 'gateway',
+                duration_ms: activeResult.durationMs,
+            });
+        }
+        else if (effectiveShouldFail) {
+            await emitRunEvent('run_failed', {
+                reason: errorMessage ?? 'Subagent run failed',
+                duration_ms: activeResult.durationMs,
+                parse_error: parseError,
+            });
+        }
+        else {
+            await emitRunEvent('run_completed', {
+                duration_ms: activeResult.durationMs,
+                parse_error: parseError,
+                retry_count: retryCount,
+            });
+        }
+        const { error: runFinalizeError } = await supabase
             .from('subagent_runs')
             .update({
-            status: wasCancelled ? 'cancelled' : shouldFail ? 'failed' : 'completed',
-            output: asJson(wasCancelled ? failureOutput : shouldFail ? failureOutput : output),
-            error: wasCancelled ? cancelReason : shouldFail ? errorMessage : null,
+            status: finalStatus,
+            output: asJson(finalOutput),
+            error: finalError,
             completed_at: completedAt,
             metadata: asJson(runMetadataUpdate),
         })
             .eq('id', resolvedRunId);
+        if (runFinalizeError) {
+            activeSubagentRuns.delete(subagentId);
+            return {
+                ok: false,
+                result: {
+                    message: 'Failed to persist terminal subagent run state',
+                    subagent_id: subagentId,
+                    run_id: resolvedRunId,
+                },
+                error: runFinalizeError.message,
+            };
+        }
         const { error: subagentUpdateError } = await supabase
             .from('subagents')
             .update({
-            status: wasCancelled ? 'failed' : shouldFail ? 'failed' : 'completed',
-            output: asJson(wasCancelled ? failureOutput : shouldFail ? failureOutput : output),
-            error: wasCancelled ? cancelReason : shouldFail ? errorMessage : null,
+            status: finalStatus,
+            output: asJson(finalOutput),
+            error: finalError,
             completed_at: completedAt,
             metadata: asJson(mergedMetadata),
         })
             .eq('id', subagentId);
         if (subagentUpdateError) {
-            logError('Failed to update subagent after run', {
+            activeSubagentRuns.delete(subagentId);
+            return {
+                ok: false,
+                result: {
+                    message: 'Failed to update subagent after run',
+                    subagent_id: subagentId,
+                    run_id: resolvedRunId,
+                },
                 error: subagentUpdateError.message,
-                subagentId,
-                runId: resolvedRunId,
-            });
+            };
         }
         activeSubagentRuns.delete(subagentId);
         return {
-            ok: !shouldFail,
+            ok: !effectiveShouldFail,
             result: {
                 subagent_id: subagentId,
-                status: shouldFail ? 'failed' : 'completed',
-                output: shouldFail ? null : output,
-                error: shouldFail ? errorMessage : null,
+                status: finalStatus,
+                output: effectiveShouldFail ? null : finalOutput,
+                error: finalError,
             },
-            error: shouldFail ? errorMessage ?? 'Subagent run failed' : undefined,
+            error: effectiveShouldFail ? errorMessage ?? 'Subagent run failed' : undefined,
         };
     }
     finally {
+        activeSubagentRuns.delete(subagentId);
         if (workDir) {
             await cleanupWorkDir(workDir, workRoot);
         }
@@ -3111,6 +3722,10 @@ async function handleModelRunJob(_supabase, job) {
     });
     const workRoot = resolveModelWorkdirRoot();
     let workDir = '';
+    const activeModelRun = {
+        shutdownRequested: false,
+    };
+    activeModelRuns.set(job.id, activeModelRun);
     try {
         workDir = await createWorkDir(workRoot, [{ value: job.id, label: 'job id' }]);
         assertSafeOutputPath(workDir, runPlan.outputPath);
@@ -3137,6 +3752,16 @@ async function handleModelRunJob(_supabase, job) {
             timeoutMs: runPlan.timeoutMs ?? DEFAULT_MODEL_RUN_TIMEOUT_MS,
             cwd: workDir,
             env: resolvedEnv,
+            onStart: (child) => {
+                activeModelRun.child = child;
+                if (activeModelRun.shutdownRequested) {
+                    requestChildTerminationWithLogging(child, {
+                        reason: activeModelRun.shutdownReason ?? 'Gateway shutting down',
+                        graceMs: PROCESS_KILL_GRACE_MS,
+                        context: 'model_run_shutdown',
+                    });
+                }
+            },
         });
         const stdoutInfo = truncateLog(runResult.stdout);
         const stderrInfo = truncateLog(runResult.stderr);
@@ -3214,11 +3839,620 @@ async function handleModelRunJob(_supabase, job) {
         };
     }
     finally {
+        activeModelRuns.delete(job.id);
         if (workDir) {
             await cleanupWorkDir(workDir, workRoot);
         }
     }
 }
+function normalizeCommandArgs(value) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        return null;
+    const normalized = [];
+    for (const item of value) {
+        if (typeof item !== 'string')
+            return null;
+        normalized.push(item);
+    }
+    return normalized;
+}
+function normalizeCommandEnv(value) {
+    if (value === undefined || value === null)
+        return {};
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const normalized = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw === 'string') {
+            normalized[key] = raw;
+            continue;
+        }
+        if (typeof raw === 'number' || typeof raw === 'boolean') {
+            normalized[key] = String(raw);
+            continue;
+        }
+        return null;
+    }
+    return normalized;
+}
+function coercePositiveInteger(value, fallback, options) {
+    const min = options?.min ?? 1;
+    const max = options?.max ?? Number.MAX_SAFE_INTEGER;
+    const parsed = typeof value === 'number'
+        ? value
+        : typeof value === 'string'
+            ? Number.parseInt(value, 10)
+            : NaN;
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return Math.max(min, Math.min(max, Math.trunc(parsed)));
+}
+function coerceNonNegativeInteger(value, fallback, options) {
+    const max = options?.max ?? Number.MAX_SAFE_INTEGER;
+    const parsed = typeof value === 'number'
+        ? value
+        : typeof value === 'string'
+            ? Number.parseInt(value, 10)
+            : NaN;
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return Math.max(0, Math.min(max, Math.trunc(parsed)));
+}
+function getRunningShellSessionCount() {
+    let count = 0;
+    for (const session of activeShellSessions.values()) {
+        if (session.status === 'running')
+            count += 1;
+    }
+    return count;
+}
+function estimateShellEventBytes(event) {
+    return Buffer.byteLength(event.data, 'utf-8') + 64;
+}
+function appendShellSessionEvent(session, stream, data, timestamp = new Date().toISOString()) {
+    if (!data)
+        return;
+    const event = {
+        sequence: session.nextSequence,
+        stream,
+        data,
+        timestamp,
+    };
+    session.nextSequence += 1;
+    session.events.push(event);
+    session.bufferedBytes += estimateShellEventBytes(event);
+    session.updatedAt = timestamp;
+    while (session.events.length > MAX_SHELL_SESSION_EVENTS ||
+        session.bufferedBytes > MAX_SHELL_SESSION_BUFFER_BYTES) {
+        const removed = session.events.shift();
+        if (!removed)
+            break;
+        session.bufferedBytes = Math.max(0, session.bufferedBytes - estimateShellEventBytes(removed));
+    }
+}
+function readShellSessionEvents(session, options) {
+    const sinceSequence = options?.sinceSequence ?? 0;
+    const maxEvents = options?.maxEvents ?? 200;
+    const pending = session.events.filter((event) => event.sequence > sinceSequence);
+    const events = pending.slice(0, maxEvents);
+    return {
+        events,
+        hasMore: pending.length > events.length,
+        latestSequence: session.nextSequence > 0 ? session.nextSequence - 1 : 0,
+    };
+}
+function purgeExpiredShellSessions(nowMs = Date.now()) {
+    for (const [sessionId, session] of activeShellSessions.entries()) {
+        if (session.status === 'running')
+            continue;
+        const updatedAtMs = Date.parse(session.updatedAt);
+        if (!Number.isFinite(updatedAtMs)) {
+            activeShellSessions.delete(sessionId);
+            continue;
+        }
+        if (nowMs - updatedAtMs >= SHELL_SESSION_RETENTION_MS) {
+            activeShellSessions.delete(sessionId);
+        }
+    }
+}
+async function validateMachineControlState(supabase, config) {
+    const installFullControlEnabled = await refreshRuntimeInstallFullControl(config);
+    const gatewayControlState = await loadGatewayControlState(supabase, config);
+    if (!gatewayControlState) {
+        return {
+            ok: false,
+            message: 'Gateway control state unavailable',
+        };
+    }
+    if (!installFullControlEnabled) {
+        return {
+            ok: false,
+            message: 'Gateway install full control is disabled. Run "panorama-gateway full-control enable" on the host.',
+        };
+    }
+    if (!gatewayControlState.full_control_enabled) {
+        return {
+            ok: false,
+            message: 'Gateway connection full control is disabled by team settings.',
+        };
+    }
+    if (gatewayControlState.status !== 'ready' ||
+        !isHeartbeatFresh(gatewayControlState.last_seen_at)) {
+        return {
+            ok: false,
+            message: 'Gateway is offline or heartbeat is stale',
+        };
+    }
+    return { ok: true };
+}
+function normalizeShellSessionAction(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'open' ||
+        normalized === 'write' ||
+        normalized === 'read' ||
+        normalized === 'close' ||
+        normalized === 'status') {
+        return normalized;
+    }
+    return null;
+}
+function resolveDefaultShellCommand() {
+    if (typeof process.env.SHELL === 'string' && process.env.SHELL.trim().length > 0) {
+        return process.env.SHELL.trim();
+    }
+    return '/bin/bash';
+}
+function buildShellSessionSummary(session) {
+    return {
+        session_id: session.id,
+        resource_id: session.resourceId,
+        status: session.status,
+        shell: session.shell,
+        shell_args: session.shellArgs,
+        cwd: session.cwd,
+        created_at: session.createdAt,
+        updated_at: session.updatedAt,
+        exit_code: session.exitCode,
+        error: session.error,
+        latest_sequence: session.nextSequence > 0 ? session.nextSequence - 1 : 0,
+    };
+}
+function cleanupShellSession(sessionId, reason) {
+    const session = activeShellSessions.get(sessionId);
+    if (!session)
+        return;
+    if (session.child) {
+        requestChildTerminationWithLogging(session.child, {
+            reason,
+            graceMs: PROCESS_KILL_GRACE_MS,
+            context: 'shell_session_cleanup',
+        });
+        session.child = undefined;
+    }
+    session.status = session.status === 'running' ? 'closed' : session.status;
+    session.updatedAt = new Date().toISOString();
+}
+async function loadGatewayJobStatus(supabase, jobId) {
+    const { data, error } = await supabase
+        .from('gateway_jobs')
+        .select('status')
+        .eq('id', jobId)
+        .maybeSingle();
+    if (error) {
+        logError('Failed to fetch gateway job status', {
+            jobId,
+            error: error.message,
+        });
+        return null;
+    }
+    if (!data || typeof data.status !== 'string') {
+        return null;
+    }
+    const status = data.status;
+    if (status === 'queued' ||
+        status === 'running' ||
+        status === 'completed' ||
+        status === 'failed' ||
+        status === 'cancelled') {
+        return status;
+    }
+    return null;
+}
+async function isGatewayJobCancelled(supabase, jobId) {
+    const status = await loadGatewayJobStatus(supabase, jobId);
+    return status === 'cancelled';
+}
+async function loadValidatedRemoteShellResource(supabase, config, resourceId, requiredAccess) {
+    const { data, error } = await supabase
+        .from('team_resources')
+        .select('id, team_id, resource_type, max_access_level, metadata')
+        .eq('id', resourceId)
+        .eq('team_id', config.teamId)
+        .maybeSingle();
+    if (error) {
+        logError('Failed to load remote shell resource for gateway validation', {
+            resourceId,
+            gatewayId: config.gatewayId,
+            teamId: config.teamId,
+            error: error.message,
+        });
+        return { ok: false, message: 'Failed to load remote shell resource' };
+    }
+    return validateRemoteShellResourceRow(data ?? null, {
+        teamId: config.teamId,
+        gatewayId: config.gatewayId,
+        requiredAccess,
+    });
+}
+function revokeShellSession(session, message) {
+    appendShellSessionEvent(session, 'system', `Session closed: ${message}`);
+    cleanupShellSession(session.id, 'shell_session_resource_revoked');
+    session.status = 'closed';
+    session.updatedAt = new Date().toISOString();
+}
+async function handleShellSessionJob(supabase, config, job) {
+    purgeExpiredShellSessions();
+    if (await isGatewayJobCancelled(supabase, job.id)) {
+        const message = 'Gateway shell session job was cancelled before execution';
+        return {
+            ok: false,
+            result: { message, cancelled: true },
+            error: message,
+        };
+    }
+    const controlValidation = await validateMachineControlState(supabase, config);
+    if (!controlValidation.ok) {
+        const message = controlValidation.message ?? 'Gateway machine control unavailable';
+        return {
+            ok: false,
+            result: { message },
+            error: message,
+        };
+    }
+    const payload = job.payload ?? {};
+    const action = normalizeShellSessionAction(payload.action);
+    if (!action) {
+        return {
+            ok: false,
+            result: { message: 'Invalid shell session action' },
+            error: 'Invalid shell session action',
+        };
+    }
+    const resourceId = typeof payload.resource_id === 'string' && payload.resource_id.trim().length > 0
+        ? payload.resource_id.trim()
+        : null;
+    if (!resourceId) {
+        return {
+            ok: false,
+            result: { message: 'Missing resource_id in payload' },
+            error: 'Missing resource_id in payload',
+        };
+    }
+    if (action === 'open') {
+        const resourceValidation = await loadValidatedRemoteShellResource(supabase, config, resourceId, 'write');
+        if (!resourceValidation.ok) {
+            return {
+                ok: false,
+                result: { message: resourceValidation.message, resource_id: resourceId },
+                error: resourceValidation.message,
+            };
+        }
+        if (getRunningShellSessionCount() >= MAX_ACTIVE_SHELL_SESSIONS) {
+            const message = `Too many active shell sessions (max ${MAX_ACTIVE_SHELL_SESSIONS})`;
+            return {
+                ok: false,
+                result: { message, max_active_sessions: MAX_ACTIVE_SHELL_SESSIONS },
+                error: message,
+            };
+        }
+        const shell = typeof payload.shell === 'string' && payload.shell.trim().length > 0
+            ? payload.shell.trim()
+            : resolveDefaultShellCommand();
+        const shellArgs = normalizeCommandArgs(payload.shell_args);
+        if (!shellArgs) {
+            return {
+                ok: false,
+                result: { message: 'Invalid shell_args in payload (expected string array)' },
+                error: 'Invalid shell_args in payload',
+            };
+        }
+        const env = normalizeCommandEnv(payload.env);
+        if (!env) {
+            return {
+                ok: false,
+                result: { message: 'Invalid env in payload (expected string/number/boolean map)' },
+                error: 'Invalid env in payload',
+            };
+        }
+        const cwd = typeof payload.cwd === 'string' && payload.cwd.trim().length > 0
+            ? payload.cwd.trim()
+            : null;
+        const requestedSessionId = typeof payload.session_id === 'string' && payload.session_id.trim().length > 0
+            ? payload.session_id.trim()
+            : null;
+        let sessionId = requestedSessionId ?? randomUUID();
+        if (requestedSessionId && activeShellSessions.has(requestedSessionId)) {
+            return {
+                ok: false,
+                result: {
+                    message: 'Shell session ID already exists',
+                    session_id: requestedSessionId,
+                },
+                error: 'Shell session ID already exists',
+            };
+        }
+        if (!requestedSessionId) {
+            let retries = 0;
+            while (activeShellSessions.has(sessionId) && retries < 5) {
+                sessionId = randomUUID();
+                retries += 1;
+            }
+            if (activeShellSessions.has(sessionId)) {
+                return {
+                    ok: false,
+                    result: {
+                        message: 'Failed to allocate unique shell session ID',
+                    },
+                    error: 'Failed to allocate unique shell session ID',
+                };
+            }
+        }
+        const nowIso = new Date().toISOString();
+        const session = {
+            id: sessionId,
+            teamId: config.teamId,
+            gatewayId: config.gatewayId,
+            resourceId,
+            shell,
+            shellArgs,
+            cwd,
+            status: 'running',
+            createdAt: nowIso,
+            updatedAt: nowIso,
+            exitCode: null,
+            error: null,
+            child: undefined,
+            events: [],
+            nextSequence: 1,
+            bufferedBytes: 0,
+        };
+        const sessionEnv = {
+            ...env,
+        };
+        if (!Object.hasOwn(sessionEnv, 'TERM')) {
+            sessionEnv.TERM = 'xterm-256color';
+        }
+        if (!Object.hasOwn(sessionEnv, 'COLUMNS')) {
+            sessionEnv.COLUMNS = String(DEFAULT_SHELL_COLUMNS);
+        }
+        if (!Object.hasOwn(sessionEnv, 'LINES')) {
+            sessionEnv.LINES = String(DEFAULT_SHELL_ROWS);
+        }
+        try {
+            const child = spawn(shell, shellArgs, {
+                cwd: cwd ?? undefined,
+                env: resolveChildProcessEnv(sessionEnv),
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            child.on('error', (error) => {
+                const now = new Date().toISOString();
+                session.status = 'failed';
+                session.error = error.message;
+                session.updatedAt = now;
+                session.child = undefined;
+                appendShellSessionEvent(session, 'system', `Session error: ${error.message}`, now);
+            });
+            child.on('close', (code) => {
+                const now = new Date().toISOString();
+                session.exitCode = code ?? null;
+                if (session.status === 'running') {
+                    session.status = 'exited';
+                }
+                session.updatedAt = now;
+                session.child = undefined;
+                appendShellSessionEvent(session, 'system', `Session exited with code ${code ?? 'unknown'}`, now);
+            });
+            child.stdout?.on('data', (chunk) => {
+                appendShellSessionEvent(session, 'stdout', chunk.toString('utf-8'));
+            });
+            child.stderr?.on('data', (chunk) => {
+                appendShellSessionEvent(session, 'stderr', chunk.toString('utf-8'));
+            });
+            await waitForChildStartup(child);
+            if (session.status !== 'running') {
+                const message = session.error ??
+                    (session.exitCode !== null
+                        ? `Shell session exited during startup with code ${session.exitCode}`
+                        : 'Shell session exited during startup');
+                return {
+                    ok: false,
+                    result: {
+                        message,
+                        ...buildShellSessionSummary(session),
+                    },
+                    error: message,
+                };
+            }
+            session.child = child;
+            activeShellSessions.set(sessionId, session);
+            appendShellSessionEvent(session, 'system', `Session opened (${shell}${shellArgs.length > 0 ? ` ${shellArgs.join(' ')}` : ''})`);
+            return {
+                ok: true,
+                result: {
+                    message: 'Shell session opened',
+                    ...buildShellSessionSummary(session),
+                    default_columns: DEFAULT_SHELL_COLUMNS,
+                    default_rows: DEFAULT_SHELL_ROWS,
+                },
+            };
+        }
+        catch (error) {
+            activeShellSessions.delete(sessionId);
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                result: {
+                    message: `Failed to open shell session: ${message}`,
+                },
+                error: `Failed to open shell session: ${message}`,
+            };
+        }
+    }
+    const sessionId = typeof payload.session_id === 'string' && payload.session_id.trim().length > 0
+        ? payload.session_id.trim()
+        : null;
+    if (!sessionId) {
+        return {
+            ok: false,
+            result: { message: 'Missing session_id in payload' },
+            error: 'Missing session_id in payload',
+        };
+    }
+    const session = activeShellSessions.get(sessionId);
+    if (!session) {
+        return {
+            ok: false,
+            result: { message: 'Shell session not found or expired', session_id: sessionId },
+            error: 'Shell session not found or expired',
+        };
+    }
+    if (session.teamId !== config.teamId || session.gatewayId !== config.gatewayId) {
+        return {
+            ok: false,
+            result: { message: 'Shell session belongs to another gateway context', session_id: sessionId },
+            error: 'Shell session belongs to another gateway context',
+        };
+    }
+    if (resourceId !== session.resourceId) {
+        return {
+            ok: false,
+            result: { message: 'Shell session resource mismatch', session_id: sessionId },
+            error: 'Shell session resource mismatch',
+        };
+    }
+    const requiredAccess = action === 'read' || action === 'status' ? 'read' : 'write';
+    const resourceValidation = await loadValidatedRemoteShellResource(supabase, config, resourceId, requiredAccess);
+    if (!resourceValidation.ok) {
+        revokeShellSession(session, resourceValidation.message);
+        return {
+            ok: false,
+            result: {
+                message: resourceValidation.message,
+                ...buildShellSessionSummary(session),
+            },
+            error: resourceValidation.message,
+        };
+    }
+    if (action === 'status') {
+        return {
+            ok: true,
+            result: {
+                message: 'Shell session status',
+                ...buildShellSessionSummary(session),
+            },
+        };
+    }
+    if (action === 'read') {
+        const sinceSequence = coerceNonNegativeInteger(payload.since_sequence, 0);
+        const maxEvents = coercePositiveInteger(payload.max_events, 200, {
+            min: 1,
+            max: 1000,
+        });
+        const readResult = readShellSessionEvents(session, { sinceSequence, maxEvents });
+        return {
+            ok: true,
+            result: {
+                message: 'Shell session output',
+                ...buildShellSessionSummary(session),
+                since_sequence: sinceSequence,
+                max_events: maxEvents,
+                has_more: readResult.hasMore,
+                events: readResult.events,
+                latest_sequence: readResult.latestSequence,
+            },
+        };
+    }
+    if (action === 'write') {
+        const input = typeof payload.input === 'string' ? payload.input : null;
+        if (input === null) {
+            return {
+                ok: false,
+                result: { message: 'Missing input in payload', session_id: sessionId },
+                error: 'Missing input in payload',
+            };
+        }
+        if (session.status !== 'running' || !session.child || !session.child.stdin) {
+            const message = `Shell session is not writable (status: ${session.status})`;
+            return {
+                ok: false,
+                result: {
+                    message,
+                    ...buildShellSessionSummary(session),
+                },
+                error: message,
+            };
+        }
+        const appendNewline = payload.append_newline === true;
+        const toWrite = appendNewline ? `${input}\n` : input;
+        const bytesWritten = Buffer.byteLength(toWrite, 'utf-8');
+        try {
+            await new Promise((resolve, reject) => {
+                session.child?.stdin?.write(toWrite, (error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+            session.updatedAt = new Date().toISOString();
+            return {
+                ok: true,
+                result: {
+                    message: 'Shell session input sent',
+                    ...buildShellSessionSummary(session),
+                    bytes_written: bytesWritten,
+                    append_newline: appendNewline,
+                },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                result: {
+                    message: `Failed to write to shell session: ${message}`,
+                    ...buildShellSessionSummary(session),
+                },
+                error: `Failed to write to shell session: ${message}`,
+            };
+        }
+    }
+    if (action === 'close') {
+        if (session.status === 'running') {
+            cleanupShellSession(session.id, 'shell_session_close');
+            appendShellSessionEvent(session, 'system', 'Session closed by request');
+        }
+        session.status = 'closed';
+        session.updatedAt = new Date().toISOString();
+        return {
+            ok: true,
+            result: {
+                message: 'Shell session closed',
+                ...buildShellSessionSummary(session),
+            },
+        };
+    }
+    return {
+        ok: false,
+        result: { message: `Unsupported shell session action: ${action}` },
+        error: `Unsupported shell session action: ${action}`,
+    };
+}
 async function failSubagentRun(supabase, job, errorMessage) {
     const payload = job.payload ?? {};
     const subagentId = typeof payload.subagent_id === 'string'
@@ -3256,15 +4490,7 @@ async function failSubagentRun(supabase, job, errorMessage) {
         .limit(1)
         .maybeSingle();
     if (runningRun?.id) {
-        const { data: lastEvent } = await supabase
-            .from('subagent_run_events')
-            .select('sequence')
-            .eq('run_id', runningRun.id)
-            .order('sequence', { ascending: false })
-            .limit(1)
-            .maybeSingle();
-        const nextSequence = lastEvent && typeof lastEvent.sequence === 'number' ? lastEvent.sequence + 1 : 0;
-        await supabase
+        const { error: runFailUpdateError } = await supabase
             .from('subagent_runs')
             .update({
             status: 'failed',
@@ -3274,15 +4500,24 @@ async function failSubagentRun(supabase, job, errorMessage) {
             metadata: asJson(mergedMetadata),
         })
             .eq('id', runningRun.id);
+        if (runFailUpdateError) {
+            logError('Failed to mark running subagent run as failed after gateway error', {
+                subagentId,
+                runId: runningRun.id,
+                error: runFailUpdateError.message,
+            });
+        }
         if (subagent.gateway_id) {
-            await supabase.from('subagent_run_events').insert({
-                run_id: runningRun.id,
-                subagent_id: subagent.id,
-                team_id: subagent.team_id,
-                gateway_id: subagent.gateway_id,
+            const nextSequence = await getNextSubagentRunEventSequence(supabase, runningRun.id);
+            await insertSubagentRunEvent({
+                supabase,
+                runId: runningRun.id,
+                subagentId: subagent.id,
+                teamId: subagent.team_id,
+                gatewayId: subagent.gateway_id,
                 sequence: nextSequence,
-                event_type: 'run_failed',
-                payload: asJson({ error: errorMessage }),
+                eventType: 'run_failed',
+                payload: { reason: errorMessage, source: 'gateway_job_failure' },
             });
         }
     }
@@ -3328,6 +4563,7 @@ async function processJob(supabase, config, job) {
         provider: jobDetails.provider ?? undefined,
         model: jobDetails.model ?? undefined,
         subagentType: jobDetails.subagent_type ?? undefined,
+        shellAction: jobDetails.shell_action ?? undefined,
     });
     if (claimed.job_type === 'diagnostic') {
         const diagnostic = await handleDiagnosticJob();
@@ -3340,12 +4576,15 @@ async function processJob(supabase, config, job) {
         return;
     }
     if (claimed.job_type === 'subagent_run') {
-        const result = await handleSubagentRunJob(supabase, claimed);
+        const result = await handleSubagentRunJob(supabase, config, claimed);
         if (result.ok) {
             await completeJob(supabase, claimed.id, 'completed', result.result);
         }
         else {
-            await completeJob(supabase, claimed.id, 'failed', result.result, result.error);
+            await completeJob(supabase, claimed.id, result.jobStatus ?? 'failed', result.result, result.error);
+            if (!result.skipSubagentFailure) {
+                await failSubagentRun(supabase, claimed, result.error ?? 'Subagent run failed');
+            }
         }
         return;
     }
@@ -3360,7 +4599,17 @@ async function processJob(supabase, config, job) {
         return;
     }
     if (claimed.job_type === 'subagent_cancel') {
-        const result = await handleSubagentCancelJob(supabase, claimed);
+        const result = await handleSubagentCancelJob(supabase, config, claimed);
+        if (result.ok) {
+            await completeJob(supabase, claimed.id, 'completed', result.result);
+        }
+        else {
+            await completeJob(supabase, claimed.id, 'failed', result.result, result.error);
+        }
+        return;
+    }
+    if (claimed.job_type === 'shell_session') {
+        const result = await handleShellSessionJob(supabase, config, claimed);
         if (result.ok) {
             await completeJob(supabase, claimed.id, 'completed', result.result);
         }
@@ -3431,6 +4680,7 @@ async function startGateway(options, configResolution) {
         }
     }
     cliInfo('Starting gateway...', options);
+    CURRENT_RUNTIME_OPTIONS = options;
     let config;
     try {
         config = await loadConfig(options);
@@ -3506,10 +4756,11 @@ async function startGateway(options, configResolution) {
     await ensureGatewayTmpDir();
     await discoverGatewayCliCommands(options);
     cliInfo('Validating providers...', options);
-    const { capabilities: initialCapabilities, providerHealth, anyProviderReady } = await buildCapabilities({
+    const { capabilities: initialCapabilities, providerHealth } = await buildCapabilities({
         validationMode: 'auto',
         previousHealth: config.providerHealth,
         deviceName,
+        installFullControlEnabled: config.full_control_enabled,
         onProgress: (event) => {
             if (event.stage === 'start') {
                 cliInfo(`  ${formatProviderLabel(event.providerId)}...`, options);
@@ -3526,8 +4777,16 @@ async function startGateway(options, configResolution) {
     let currentProviderHealth = providerHealth;
     CURRENT_CAPABILITIES = initialCapabilities;
     CURRENT_PROVIDER_HEALTH = providerHealth;
+    CURRENT_JOB_INGRESS_STATE = {
+        pending: true,
+        ready: false,
+    };
     const providerStatus = currentCapabilities.providers;
-    const initialStatus = anyProviderReady ? 'ready' : 'error';
+    const initialStatus = computeGatewayOperationalStatus({
+        capabilities: currentCapabilities,
+        jobIngressState: CURRENT_JOB_INGRESS_STATE,
+        acceptingJobs: CURRENT_ACCEPTING_JOBS,
+    });
     logInfo('Gateway capabilities loaded', {
         providers: Object.fromEntries(Object.entries(providerStatus).map(([id, entry]) => [
             id,
@@ -3555,19 +4814,32 @@ async function startGateway(options, configResolution) {
     if (ranFullValidation) {
         await emitProviderHealthEvents(supabase, config, providerHealth, 'startup');
     }
-    await sendHeartbeat(supabase, initialStatus, currentCapabilities, deviceName);
     let heartbeatStatus = initialStatus;
+    await sendHeartbeat(supabase, heartbeatStatus, currentCapabilities, deviceName);
     await writePidFile(process.pid, options);
     let heartbeatInFlight = false;
+    const syncOperationalHeartbeatIfChanged = async () => {
+        const nextStatus = computeGatewayOperationalStatus({
+            capabilities: currentCapabilities,
+            jobIngressState: CURRENT_JOB_INGRESS_STATE,
+            acceptingJobs: CURRENT_ACCEPTING_JOBS,
+        });
+        if (nextStatus === heartbeatStatus)
+            return;
+        heartbeatStatus = nextStatus;
+        await sendHeartbeat(supabase, heartbeatStatus, currentCapabilities, deviceName);
+    };
     const refreshHeartbeat = async () => {
         if (heartbeatInFlight)
             return;
         heartbeatInFlight = true;
         try {
-            const { capabilities: nextCapabilities, providerHealth: nextProviderHealth, anyProviderReady: nextReady, } = await buildCapabilities({
+            const installFullControlEnabled = await refreshRuntimeInstallFullControl(config);
+            const { capabilities: nextCapabilities, providerHealth: nextProviderHealth, } = await buildCapabilities({
                 validationMode: 'light',
                 previousHealth: CURRENT_PROVIDER_HEALTH ?? currentProviderHealth,
                 deviceName,
+                installFullControlEnabled,
                 onProgress: (event) => {
                     if (event.stage === 'start')
                         return;
@@ -3584,7 +4856,11 @@ async function startGateway(options, configResolution) {
             config.providerHealth = nextProviderHealth;
             CURRENT_CAPABILITIES = nextCapabilities;
             CURRENT_PROVIDER_HEALTH = nextProviderHealth;
-            heartbeatStatus = nextReady ? 'ready' : 'error';
+            heartbeatStatus = computeGatewayOperationalStatus({
+                capabilities: nextCapabilities,
+                jobIngressState: CURRENT_JOB_INGRESS_STATE,
+                acceptingJobs: CURRENT_ACCEPTING_JOBS,
+            });
             await sendHeartbeat(supabase, heartbeatStatus, currentCapabilities, deviceName);
         }
         catch (error) {
@@ -3602,12 +4878,63 @@ async function startGateway(options, configResolution) {
         void refreshHeartbeat();
     }, DEFAULT_HEARTBEAT_INTERVAL_MS);
     let acceptingJobs = true;
+    CURRENT_ACCEPTING_JOBS = true;
     let restartRequested = false;
     let restartDetectedAt = null;
     let restartTimer = null;
-    const pendingJobs = [];
-    const queuedJobIds = new Set();
-    const activeJobIds = new Set();
+    let reconcileTimer = null;
+    let channelReconnectTimer = null;
+    const jobQueue = new GatewayJobQueue(resolveJobSubagentId);
+    const activeClaimedJobs = new Map();
+    let lastJobIngressSuccessAtMs = null;
+    let lastJobIngressError = null;
+    let reconcileInFlight = false;
+    let shutdownInProgress = false;
+    const updateJobIngressState = () => {
+        const ready = lastJobIngressSuccessAtMs !== null &&
+            Date.now() - lastJobIngressSuccessAtMs <= DEFAULT_JOB_RECONCILE_INTERVAL_MS * 3;
+        const pending = lastJobIngressSuccessAtMs === null && lastJobIngressError === null;
+        CURRENT_JOB_INGRESS_STATE = {
+            pending,
+            ready,
+        };
+    };
+    const reconcileQueuedJobs = async (reason) => {
+        if (reconcileInFlight || shutdownInProgress)
+            return;
+        reconcileInFlight = true;
+        try {
+            const { data, error } = await supabase
+                .from('gateway_jobs')
+                .select('*')
+                .eq('team_id', config.teamId)
+                .eq('status', 'queued')
+                .eq('gateway_id', config.gatewayId)
+                .order('created_at', { ascending: true });
+            if (error) {
+                throw error;
+            }
+            lastJobIngressSuccessAtMs = Date.now();
+            lastJobIngressError = null;
+            updateJobIngressState();
+            for (const row of data ?? []) {
+                enqueueJob(row);
+            }
+            await syncOperationalHeartbeatIfChanged();
+        }
+        catch (error) {
+            lastJobIngressError = error instanceof Error ? error.message : String(error);
+            updateJobIngressState();
+            logError('Failed to reconcile queued gateway jobs', {
+                error: lastJobIngressError,
+                reason,
+            });
+            await syncOperationalHeartbeatIfChanged();
+        }
+        finally {
+            reconcileInFlight = false;
+        }
+    };
     const entryPath = process.argv[1] || '';
     let modulePath = '';
     try {
@@ -3635,7 +4962,10 @@ async function startGateway(options, configResolution) {
     const maybeRestart = async () => {
         if (!restartRequested)
             return;
-        if (activeJobIds.size > 0 || activeSubagentRuns.size > 0) {
+        if (jobQueue.activeCount() > 0 ||
+            activeSubagentRuns.size > 0 ||
+            activeModelRuns.size > 0 ||
+            getRunningShellSessionCount() > 0) {
             return;
         }
         await restartGateway('all jobs complete');
@@ -3646,13 +4976,16 @@ async function startGateway(options, configResolution) {
         restartRequested = true;
         restartDetectedAt = Date.now();
         acceptingJobs = false;
-        pendingJobs.length = 0;
-        queuedJobIds.clear();
+        CURRENT_ACCEPTING_JOBS = false;
+        jobQueue.clearPending();
         logInfo('Gateway update detected; draining before restart', {
             reason,
-            active_jobs: activeJobIds.size,
+            active_jobs: jobQueue.activeCount(),
             active_subagent_runs: activeSubagentRuns.size,
+            active_model_runs: activeModelRuns.size,
+            active_shell_sessions: getRunningShellSessionCount(),
         });
+        void syncOperationalHeartbeatIfChanged();
         void maybeRestart();
     };
     const checkForUpgrade = () => {
@@ -3680,7 +5013,7 @@ async function startGateway(options, configResolution) {
         const claimed = await claimJob(supabase, config, job);
         if (!claimed)
             return;
-        const result = await handleSubagentCancelJob(supabase, claimed);
+        const result = await handleSubagentCancelJob(supabase, config, claimed);
         if (result.ok) {
             await completeJob(supabase, claimed.id, 'completed', result.result);
         }
@@ -3688,7 +5021,8 @@ async function startGateway(options, configResolution) {
             await completeJob(supabase, claimed.id, 'failed', result.result, result.error);
         }
     };
-    const processJobWithHandling = async (nextJob) => {
+    const processJobWithHandling = async (nextJob, reservedSubagentId) => {
+        activeClaimedJobs.set(nextJob.id, nextJob);
         try {
             await processJob(supabase, config, nextJob);
         }
@@ -3704,7 +5038,8 @@ async function startGateway(options, configResolution) {
             }
         }
         finally {
-            activeJobIds.delete(nextJob.id);
+            activeClaimedJobs.delete(nextJob.id);
+            jobQueue.markDone(nextJob.id, reservedSubagentId);
             void processQueue();
             void maybeRestart();
         }
@@ -3712,15 +5047,9 @@ async function startGateway(options, configResolution) {
     const processQueue = async () => {
         if (!acceptingJobs)
             return;
-        while (activeJobIds.size < GATEWAY_CONCURRENCY && pendingJobs.length > 0) {
-            const nextJob = pendingJobs.shift();
-            if (!nextJob)
-                break;
-            queuedJobIds.delete(nextJob.id);
-            if (activeJobIds.has(nextJob.id))
-                continue;
-            activeJobIds.add(nextJob.id);
-            void processJobWithHandling(nextJob);
+        const readyJobs = jobQueue.takeAvailable(GATEWAY_CONCURRENCY);
+        for (const nextJob of readyJobs) {
+            void processJobWithHandling(nextJob.job, nextJob.reservedSubagentId);
         }
     };
     const enqueueJob = (job) => {
@@ -3733,73 +5062,275 @@ async function startGateway(options, configResolution) {
         if (!acceptingJobs) {
             return;
         }
-        if (queuedJobIds.has(job.id) || activeJobIds.has(job.id)) {
-            return;
+        if (jobQueue.enqueue(job)) {
+            void processQueue();
         }
-        pendingJobs.push(job);
-        queuedJobIds.add(job.id);
-        void processQueue();
     };
     let channel = null;
-    const { data: backlog, error: backlogError } = await supabase
-        .from('gateway_jobs')
-        .select('*')
-        .eq('team_id', config.teamId)
-        .eq('status', 'queued')
-        .or(`gateway_id.is.null,gateway_id.eq.${config.gatewayId}`)
-        .order('created_at', { ascending: true });
-    if (backlogError) {
-        logError('Failed to fetch queued gateway jobs', { error: backlogError.message });
-    }
-    else if (backlog && backlog.length > 0) {
-        backlog.forEach((job) => enqueueJob(job));
-    }
-    channel = supabase
-        .channel(`gateway_jobs_${config.gatewayId}`)
-        .on('postgres_changes', {
-        event: 'INSERT',
-        schema: 'public',
-        table: 'gateway_jobs',
-        filter: `team_id=eq.${config.teamId}`,
-    }, (payload) => {
-        const job = payload.new;
-        if (job.status !== 'queued')
+    const scheduleChannelReconnect = (reason) => {
+        if (shutdownInProgress || channelReconnectTimer)
             return;
-        enqueueJob(job);
-    })
-        .subscribe((status) => {
-        if (status === 'SUBSCRIBED') {
-            logInfo('Gateway subscribed to job queue');
+        channelReconnectTimer = setTimeout(() => {
+            channelReconnectTimer = null;
+            void connectJobChannel(`reconnect:${reason}`);
+        }, DEFAULT_JOB_CHANNEL_RECONNECT_MS);
+    };
+    const connectJobChannel = async (reason) => {
+        if (shutdownInProgress)
+            return;
+        if (channel) {
+            try {
+                await channel.unsubscribe();
+            }
+            catch {
+                // ignore unsubscribe failures during reconnect
+            }
         }
-        if (status === 'CHANNEL_ERROR') {
-            logError('Gateway realtime channel error');
-            heartbeatStatus = 'error';
+        channel = supabase
+            .channel(`gateway_jobs_${config.gatewayId}`)
+            .on('postgres_changes', {
+            event: 'INSERT',
+            schema: 'public',
+            table: 'gateway_jobs',
+            filter: `team_id=eq.${config.teamId}`,
+        }, (payload) => {
+            const job = payload.new;
+            if (job.status !== 'queued')
+                return;
+            enqueueJob(job);
+        })
+            .subscribe((status) => {
+            if (status === 'SUBSCRIBED') {
+                logInfo('Gateway subscribed to job queue', { reason });
+                void reconcileQueuedJobs(`channel_subscribed:${reason}`);
+                return;
+            }
+            if (status === 'CHANNEL_ERROR' ||
+                status === 'TIMED_OUT' ||
+                status === 'CLOSED') {
+                logError('Gateway realtime channel unavailable', { status, reason });
+                scheduleChannelReconnect(status.toLowerCase());
+            }
+        });
+    };
+    const requestActiveJobShutdown = (reason) => {
+        for (const activeRun of activeSubagentRuns.values()) {
+            activeRun.cancelled = true;
+            activeRun.cancelReason = reason;
+            requestChildTerminationWithLogging(activeRun.child, {
+                reason,
+                graceMs: SUBAGENT_CANCEL_KILL_TIMEOUT_MS,
+                context: 'gateway_shutdown_subagent',
+            });
         }
-    });
-    let shutdownInProgress = false;
+        for (const activeModelRun of activeModelRuns.values()) {
+            activeModelRun.shutdownRequested = true;
+            activeModelRun.shutdownReason = reason;
+            requestChildTerminationWithLogging(activeModelRun.child, {
+                reason,
+                graceMs: PROCESS_KILL_GRACE_MS,
+                context: 'gateway_shutdown_model_run',
+            });
+        }
+    };
+    const waitForActiveJobsToDrain = async (graceMs) => {
+        const deadline = Date.now() + graceMs;
+        while (Date.now() < deadline) {
+            if (activeClaimedJobs.size === 0 &&
+                activeSubagentRuns.size === 0 &&
+                activeModelRuns.size === 0) {
+                return;
+            }
+            await sleep(100);
+        }
+    };
+    const cancelSubagentRunOnShutdown = async (subagentId, runId, reason) => {
+        const nowIso = new Date().toISOString();
+        const cancelledOutput = buildErrorOutput(reason);
+        const { data: subagentRow, error: subagentLoadError } = await supabase
+            .from('subagents')
+            .select('team_id, gateway_id, metadata')
+            .eq('id', subagentId)
+            .maybeSingle();
+        if (subagentLoadError) {
+            logError('Failed to load subagent during shutdown cancellation', {
+                subagentId,
+                runId,
+                error: subagentLoadError.message,
+            });
+            return;
+        }
+        const { data: runRow, error: runLoadError } = await supabase
+            .from('subagent_runs')
+            .select('team_id, gateway_id, metadata')
+            .eq('id', runId)
+            .maybeSingle();
+        if (runLoadError) {
+            logError('Failed to load subagent run during shutdown cancellation', {
+                subagentId,
+                runId,
+                error: runLoadError.message,
+            });
+            return;
+        }
+        const updatedRunMetadata = {
+            ...buildRequestedCancelMetadata({
+                base: (runRow?.metadata ?? {}),
+                run_id: runId,
+                reason,
+                requested_at: nowIso,
+                cancel_support: 'gateway',
+                cancellation_scope: 'gateway',
+            }),
+            cancel_state: 'acknowledged',
+            cancelled: true,
+            last_run_at: nowIso,
+        };
+        const { data: updatedRun, error: runUpdateError } = await supabase
+            .from('subagent_runs')
+            .update({
+            status: 'cancelled',
+            output: asJson(cancelledOutput),
+            error: reason,
+            completed_at: nowIso,
+            metadata: asJson(updatedRunMetadata),
+        })
+            .eq('id', runId)
+            .eq('status', 'running')
+            .select('id')
+            .maybeSingle();
+        if (runUpdateError) {
+            logError('Failed to cancel subagent run during shutdown', {
+                subagentId,
+                runId,
+                error: runUpdateError.message,
+            });
+        }
+        const updatedSubagentMetadata = mergeMetadata((subagentRow?.metadata ?? {}), {
+            cancel_run_id: runId,
+            cancel_requested_at: nowIso,
+            cancel_reason: reason,
+            cancel_state: 'acknowledged',
+            cancel_support: 'gateway',
+            cancellation_scope: 'gateway',
+            cancelled: true,
+            last_run_at: nowIso,
+        });
+        const { error: subagentUpdateError } = await supabase
+            .from('subagents')
+            .update({
+            status: 'cancelled',
+            output: asJson(cancelledOutput),
+            error: reason,
+            completed_at: nowIso,
+            metadata: asJson(updatedSubagentMetadata),
+        })
+            .eq('id', subagentId)
+            .eq('status', 'running');
+        if (subagentUpdateError) {
+            logError('Failed to cancel subagent during shutdown', {
+                subagentId,
+                runId,
+                error: subagentUpdateError.message,
+            });
+        }
+        if (updatedRun?.id && subagentRow?.team_id) {
+            const nextSequence = await getNextSubagentRunEventSequence(supabase, runId);
+            await insertSubagentRunEvent({
+                supabase,
+                runId,
+                subagentId,
+                teamId: subagentRow.team_id,
+                gatewayId: subagentRow.gateway_id,
+                sequence: nextSequence,
+                eventType: 'cancellation_acknowledged',
+                payload: {
+                    reason,
+                    source: 'gateway_shutdown',
+                    cancellation_scope: 'gateway',
+                },
+            });
+            await insertSubagentRunEvent({
+                supabase,
+                runId,
+                subagentId,
+                teamId: subagentRow.team_id,
+                gatewayId: subagentRow.gateway_id,
+                sequence: nextSequence + 1,
+                eventType: 'run_cancelled',
+                payload: {
+                    reason,
+                    source: 'gateway_shutdown',
+                    cancellation_scope: 'gateway',
+                },
+            });
+        }
+    };
+    const finalizeResidualGatewayJobs = async (reason) => {
+        for (const [jobId, jobRow] of activeClaimedJobs.entries()) {
+            if (jobRow.job_type === 'subagent_run') {
+                const subagentId = resolveJobSubagentId(jobRow);
+                const activeRun = subagentId ? activeSubagentRuns.get(subagentId) : null;
+                if (subagentId && activeRun) {
+                    await cancelSubagentRunOnShutdown(subagentId, activeRun.runId, reason);
+                }
+                await completeJob(supabase, jobId, 'cancelled', { message: reason, cancelled: true }, reason);
+                continue;
+            }
+            await completeJob(supabase, jobId, 'cancelled', { message: reason, cancelled: true }, reason);
+        }
+    };
+    await connectJobChannel('startup');
+    await reconcileQueuedJobs('startup');
+    reconcileTimer = setInterval(() => {
+        void reconcileQueuedJobs('interval');
+    }, DEFAULT_JOB_RECONCILE_INTERVAL_MS);
     const performShutdown = async (signal) => {
         if (shutdownInProgress)
             return;
         shutdownInProgress = true;
+        acceptingJobs = false;
+        CURRENT_ACCEPTING_JOBS = false;
+        jobQueue.clearPending();
         logInfo('Gateway shutting down', { signal });
         clearInterval(heartbeatTimer);
+        if (reconcileTimer) {
+            clearInterval(reconcileTimer);
+        }
+        if (channelReconnectTimer) {
+            clearTimeout(channelReconnectTimer);
+        }
         if (restartTimer) {
             clearInterval(restartTimer);
         }
+        await syncOperationalHeartbeatIfChanged();
+        requestActiveJobShutdown(`Gateway shutting down (${signal})`);
+        await waitForActiveJobsToDrain(DEFAULT_GATEWAY_SHUTDOWN_GRACE_MS);
+        await finalizeResidualGatewayJobs(`Gateway shutting down (${signal})`);
+        for (const sessionId of activeShellSessions.keys()) {
+            cleanupShellSession(sessionId, `gateway_shutdown_${signal}`);
+        }
         heartbeatStatus = 'offline';
+        CURRENT_JOB_INGRESS_STATE = {
+            pending: false,
+            ready: false,
+        };
         await sendHeartbeat(supabase, 'offline', currentCapabilities, deviceName);
         if (channel) {
             await channel.unsubscribe();
         }
         await removePidFile(options);
+        CURRENT_RUNTIME_OPTIONS = null;
     };
     async function restartGateway(reason) {
         if (shutdownInProgress)
             return;
         logInfo('Gateway restarting', {
             reason,
-            active_jobs: activeJobIds.size,
+            active_jobs: jobQueue.activeCount(),
             active_subagent_runs: activeSubagentRuns.size,
+            active_model_runs: activeModelRuns.size,
+            active_shell_sessions: getRunningShellSessionCount(),
         });
         const child = spawn(process.execPath, process.argv.slice(1), {
             stdio: 'inherit',
@@ -3827,8 +5358,10 @@ async function startGateway(options, configResolution) {
                 if (elapsedMs >= restartMaxWaitMs) {
                     logInfo('Gateway restart max wait reached; restarting anyway', {
                         wait_ms: elapsedMs,
-                        active_jobs: activeJobIds.size,
+                        active_jobs: jobQueue.activeCount(),
                         active_subagent_runs: activeSubagentRuns.size,
+                        active_model_runs: activeModelRuns.size,
+                        active_shell_sessions: getRunningShellSessionCount(),
                     });
                     void restartGateway('restart max wait exceeded');
                 }
@@ -3848,12 +5381,14 @@ async function startGateway(options, configResolution) {
         gatewayId: config.gatewayId,
         teamId: config.teamId,
         deviceName,
+        installFullControlEnabled: config.full_control_enabled,
         heartbeatIntervalMs: DEFAULT_HEARTBEAT_INTERVAL_MS,
         concurrency: GATEWAY_CONCURRENCY,
     });
     cliSuccess('Gateway running', options, [
         { label: 'Mode', value: 'Foreground' },
         { label: 'Device', value: deviceName },
+        { label: 'Install full control', value: config.full_control_enabled ? 'Enabled' : 'Disabled' },
         { label: 'Gateway ID', value: config.gatewayId, verboseOnly: true },
         { label: 'Team ID', value: config.teamId, verboseOnly: true },
     ]);
@@ -3911,6 +5446,7 @@ async function statusGateway(options) {
                 gatewayId: config.gatewayId,
                 teamId: config.teamId,
                 deviceName: config.deviceName ?? undefined,
+                fullControlEnabled: config.full_control_enabled === true,
             };
         }
         catch {
@@ -3925,6 +5461,14 @@ async function statusGateway(options) {
         { label: 'Version', value: version ?? undefined },
         { label: 'Uptime', value: uptime ?? undefined },
         { label: 'Paired', value: configExists ? 'Yes' : 'No' },
+        {
+            label: 'Install full control',
+            value: configSummary == null
+                ? undefined
+                : configSummary.fullControlEnabled
+                    ? 'Enabled'
+                    : 'Disabled',
+        },
         { label: 'Device', value: configSummary?.deviceName ?? undefined, verboseOnly: true },
         { label: 'Gateway ID', value: configSummary?.gatewayId ?? undefined, verboseOnly: true },
         { label: 'Team ID', value: configSummary?.teamId ?? undefined, verboseOnly: true },
@@ -3935,6 +5479,40 @@ async function statusGateway(options) {
         { label: 'PID Path', value: formatPathForDisplay(pidPath), verboseOnly: true },
     ]);
 }
+async function fullControlGateway(options, positional) {
+    const action = (positional[0] ?? 'status').trim().toLowerCase();
+    let config;
+    try {
+        config = await loadConfig(options);
+    }
+    catch (error) {
+        const details = error instanceof Error ? error.message : String(error);
+        throw new GatewayCliError('Gateway config not found. Run "pair" first.', details);
+    }
+    if (action === 'status') {
+        cliInfo('Gateway install full control', options, [
+            { label: 'Enabled', value: config.full_control_enabled ? 'Yes' : 'No' },
+            { label: 'Gateway ID', value: config.gatewayId, verboseOnly: true },
+        ]);
+        return;
+    }
+    const enabled = action === 'enable' || action === 'on' || action === 'true';
+    const disabled = action === 'disable' || action === 'off' || action === 'false';
+    if (!enabled && !disabled) {
+        throw new GatewayCliError('Unknown full-control command.', 'Use one of: enable, disable, status');
+    }
+    const nextValue = enabled;
+    if (config.full_control_enabled === nextValue) {
+        cliInfo(`Gateway install full control already ${nextValue ? 'enabled' : 'disabled'}.`, options);
+        return;
+    }
+    config.full_control_enabled = nextValue;
+    await saveConfig(config, options);
+    if (CURRENT_CONFIG && CURRENT_CONFIG.gatewayId === config.gatewayId) {
+        CURRENT_CONFIG.full_control_enabled = nextValue;
+    }
+    cliSuccess(`Gateway install full control ${nextValue ? 'enabled' : 'disabled'}.`, options, [{ label: 'Gateway ID', value: config.gatewayId, verboseOnly: true }]);
+}
 async function doctorGateway(options, configResolution) {
     const { configPath, configDir } = resolveGatewayPaths(options);
     const configExists = fsSync.existsSync(configPath);
@@ -3953,6 +5531,10 @@ async function doctorGateway(options, configResolution) {
     cliInfo('Gateway doctor report', options, [
         { label: 'Config dir', value: formatPathForDisplay(configDir) },
         { label: 'Paired', value: configExists ? 'Yes' : 'No' },
+        {
+            label: 'Install full control',
+            value: config == null ? undefined : config.full_control_enabled ? 'Enabled' : 'Disabled',
+        },
         { label: 'Gateway ID', value: config?.gatewayId ?? undefined, verboseOnly: true },
         { label: 'Team ID', value: config?.teamId ?? undefined, verboseOnly: true },
     ]);
@@ -3961,6 +5543,7 @@ async function doctorGateway(options, configResolution) {
     const { providerHealth, anyProviderReady } = await buildCapabilities({
         validationMode: 'full',
         previousHealth: config?.providerHealth,
+        installFullControlEnabled: config?.full_control_enabled === true,
         onProgress: (event) => {
             if (event.stage === 'start') {
                 cliInfo(`  ${formatProviderLabel(event.providerId)}...`, options);
@@ -4101,6 +5684,10 @@ async function run() {
         await startGateway(parsed.options, configResolution);
         return;
     }
+    if (parsed.command === 'full-control') {
+        await fullControlGateway(parsed.options, parsed.positional);
+        return;
+    }
     if (parsed.command === 'stop') {
         await stopGateway(parsed.options);
         return;