@lazyingart/agintiflow 0.6.0 → 0.8.0

package/src/cli.js

@@ -4,6 +4,8 @@ import { listAgentWrappers } from "./tool-wrappers.js";
 import { getModelPresets } from "./model-routing.js";
 import { getDockerSandboxStatus, runDockerPreflight } from "./docker-sandbox.js";
 import { buildCapabilityReport, printCapabilityReport } from "./capabilities.js";
+import { startInteractiveCli } from "./interactive-cli.js";
+import { SessionStore } from "./session-store.js";
 import {
   doctorReport,
   initProject,
@@ -52,9 +54,11 @@ export function parseArgs(argv) {
     sandboxStatus: false,
     sandboxPreflight: false,
     web: false,
+    interactive: false,
     port: "",
     host: "",
     listProfiles: false,
+    latex: false,
   };
 
   const parts = [];
@@ -64,6 +68,10 @@ export function parseArgs(argv) {
       result.web = true;
       continue;
     }
+    if (arg === "chat" || arg === "interactive" || arg === "--chat" || arg === "--interactive") {
+      result.interactive = true;
+      continue;
+    }
     if (arg === "--port") {
       result.port = readOption(argv, i);
       i += 1;
@@ -124,6 +132,14 @@ export function parseArgs(argv) {
       result.sandboxMode = result.sandboxMode || "docker-workspace";
       continue;
     }
+    if (arg === "--latex") {
+      result.latex = true;
+      result.taskProfile = "latex";
+      result.sandboxMode = result.sandboxMode || "docker-workspace";
+      result.packageInstallPolicy = result.packageInstallPolicy || "allow";
+      result.maxSteps = result.maxSteps || 30;
+      continue;
+    }
     if (arg === "--max-steps") {
       result.maxSteps = Number(readOption(argv, i));
       i += 1;
@@ -133,6 +149,10 @@ export function parseArgs(argv) {
       result.allowShellTool = true;
       continue;
     }
+    if (arg === "--no-shell") {
+      result.allowShellTool = false;
+      continue;
+    }
     if (arg === "--allow-destructive" || arg === "--trusted-host-shell") {
       result.allowDestructive = true;
       continue;
@@ -197,6 +217,31 @@ export function parseArgs(argv) {
   return result;
 }
 
+function printUsage() {
+  console.log(
+    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti queue <session-id> "message" OR aginti [--latex] [--routing smart|fast|complex|manual] [--provider deepseek|openai|mock] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-destructive] [--allow-file-tools|--no-file-tools] [--allow-wrappers --wrapper codex] [--sandbox-status|--sandbox-preflight] "your task"'
+  );
+}
+
+function agentDefaults(args) {
+  const defaults = {
+    ...args,
+    allowShellTool: args.allowShellTool ?? true,
+    allowFileTools: args.allowFileTools ?? true,
+    sandboxMode: args.sandboxMode || "docker-workspace",
+    packageInstallPolicy: args.packageInstallPolicy || "allow",
+    useDockerSandbox: args.useDockerSandbox ?? true,
+    maxSteps: args.maxSteps || (args.latex || args.taskProfile === "latex" ? 30 : 24),
+  };
+
+  if (defaults.sandboxMode === "host") {
+    defaults.useDockerSandbox = false;
+    defaults.packageInstallPolicy = args.packageInstallPolicy || "prompt";
+  }
+
+  return defaults;
+}
+
 function printRoutes() {
   const presets = getModelPresets();
   for (const preset of Object.values(presets)) {
@@ -311,7 +356,26 @@ async function handleSessionsCommand(argv) {
   process.exit(1);
 }
 
+async function handleQueueCommand(argv) {
+  const sessionId = argv[0] || "";
+  const content = argv.slice(1).join(" ").trim();
+  if (!/^[A-Za-z0-9._:-]+$/.test(sessionId) || !content) {
+    console.error('Usage: aginti queue <session-id> "message to apply during the next agent step"');
+    process.exit(1);
+  }
+
+  const store = new SessionStore(path.resolve(process.cwd(), ".sessions"), sessionId);
+  await store.appendInbox(content, { source: "cli" });
+  await store.appendEvent("conversation.queued_input", { prompt: content, source: "cli" }).catch(() => {});
+  console.log(`queued message for ${sessionId}`);
+}
+
 export async function main(argv = process.argv.slice(2)) {
+  if (argv[0] === "--help" || argv[0] === "help" || argv[0] === "-h") {
+    printUsage();
+    return;
+  }
+
   if (argv[0] === "--version" || argv[0] === "version" || argv[0] === "-v") {
     console.log(packageJson.version);
     return;
@@ -386,6 +450,11 @@ export async function main(argv = process.argv.slice(2)) {
     return;
   }
 
+  if (argv[0] === "queue") {
+    await handleQueueCommand(argv.slice(1));
+    return;
+  }
+
   if (argv[0] === "resume") {
     const sessionId = argv[1] || "";
     const prompt = argv.slice(2).join(" ").trim();
@@ -393,13 +462,18 @@ export async function main(argv = process.argv.slice(2)) {
       console.error('Usage: aginti resume <session-id> "new prompt"');
       process.exit(1);
     }
-    const config = loadConfig({ ...parseArgs([prompt]), resume: sessionId, goal: prompt }, { packageDir });
+    const config = loadConfig(agentDefaults({ ...parseArgs([prompt]), resume: sessionId, goal: prompt }), { packageDir });
     await runAgent(config);
     return;
   }
 
   const args = parseArgs(argv);
 
+  if (args.interactive || (!args.goal && !args.resume && process.stdin.isTTY)) {
+    await startInteractiveCli(agentDefaults(args), { packageDir, packageVersion: packageJson.version });
+    return;
+  }
+
   if (args.web) {
     if (args.port) process.env.PORT = String(args.port);
     if (args.host) process.env.HOST = String(args.host);
@@ -433,12 +507,10 @@ export async function main(argv = process.argv.slice(2)) {
   }
 
   if (!args.goal && !args.resume) {
-    console.error(
-      'Usage: aginti-cli web [--port 3210] OR aginti-cli [--routing smart|fast|complex|manual] [--provider deepseek|openai|mock] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell] [--allow-destructive] [--allow-file-tools|--no-file-tools] [--allow-wrappers --wrapper codex] [--sandbox-status|--sandbox-preflight] "your task"'
-    );
+    printUsage();
     process.exit(1);
   }
 
-  const config = loadConfig(args, { packageDir });
+  const config = loadConfig(agentDefaults(args), { packageDir });
   await runAgent(config);
 }

package/src/command-policy.js

@@ -39,6 +39,7 @@ const TEST_PATTERNS = [
 ];
 
 const SAFE_WORKSPACE_WRITE_PATTERNS = [/^mkdir\s+-p\s+[-\w./]+$/];
+const PERMISSION_CHANGE_PATTERNS = [/^(?:sudo\s+)?chmod\s+[-+=,rwxugoXst0-7]+\s+[-\w./]+$/];
 
 const NETWORK_FETCH_PATTERNS = [
   /^curl\s+(?:-[A-Za-z0-9]*\s+)*https?:\/\/\S+(?:\s+-o\s+[-\w./]+)?$/,
@@ -153,15 +154,6 @@ function classifySimpleCommand(normalized) {
     return { category: "blocked", reason: "Command is blocked because it references secrets or credential files." };
   }
 
-  const lowered = ` ${normalized.toLowerCase()} `;
-  if (BLOCKED_SHELL_TOKENS.some((part) => normalized.includes(part))) {
-    return {
-      category: "general-shell",
-      needsNetwork: true,
-      writesWorkspace: true,
-      reason: `Command uses general shell syntax: ${normalized}`,
-    };
-  }
   if (matchAny(SAFE_WORKSPACE_WRITE_PATTERNS, normalized)) {
     const target = normalized.replace(/^mkdir\s+-p\s+/, "");
     const virtualWorkspacePath = isSafeVirtualWorkspaceDir(target);
@@ -170,6 +162,16 @@ function classifySimpleCommand(normalized) {
     }
     return { category: "workspace-write", needsNetwork: false, writesWorkspace: true, virtualWorkspacePath };
   }
+  if (matchAny(PERMISSION_CHANGE_PATTERNS, normalized)) {
+    return {
+      category: "permission-change",
+      needsNetwork: false,
+      writesWorkspace: true,
+      reason: `Command changes workspace file mode: ${normalized}`,
+    };
+  }
+
+  const lowered = ` ${normalized.toLowerCase()} `;
   if (BLOCKED_WRITE_TOKENS.some((part) => lowered.includes(part))) {
     return {
       category: "destructive",
@@ -178,6 +180,14 @@ function classifySimpleCommand(normalized) {
       reason: `Command contains a write-capable or destructive token: ${normalized}`,
     };
   }
+  if (BLOCKED_SHELL_TOKENS.some((part) => normalized.includes(part))) {
+    return {
+      category: "general-shell",
+      needsNetwork: true,
+      writesWorkspace: true,
+      reason: `Command uses general shell syntax: ${normalized}`,
+    };
+  }
 
   if (matchAny(READ_ONLY_PATTERNS, normalized)) {
     return { category: "read-only", needsNetwork: false, writesWorkspace: false };
@@ -306,6 +316,20 @@ export function evaluateCommandPolicy(command, config) {
     };
   }
 
+  if (classification.category === "permission-change" && !trustedDockerShell && !trustedHostShell) {
+    return {
+      allowed: false,
+      ...classification,
+      needsApproval: true,
+      reason:
+        sandboxMode === "host"
+          ? "Workspace permission changes on the host require Allow destructive actions. Prefer Docker workspace mode."
+          : "Docker permission changes require docker-workspace mode with Package installs = allow.",
+      sandboxMode,
+      packageInstallPolicy,
+    };
+  }
+
   if (classification.category === "destructive" && !config.allowDestructive) {
     return {
       allowed: false,

package/src/config.js

@@ -42,9 +42,9 @@ export function resolveRuntimeConfig(args, overrides = {}) {
 
   const defaults = getProviderDefaults(route.provider);
   const packageDir = path.resolve(overrides.packageDir || process.env.AGINTIFLOW_PACKAGE_DIR || baseDir);
-  const dockerRequested = parseBoolean(overrides.useDockerSandbox ?? args.useDockerSandbox ?? process.env.USE_DOCKER_SANDBOX, false);
+  const dockerRequested = parseBoolean(overrides.useDockerSandbox ?? args.useDockerSandbox ?? process.env.USE_DOCKER_SANDBOX, true);
   const requestedSandboxMode =
-    overrides.sandboxMode || args.sandboxMode || process.env.SANDBOX_MODE || (dockerRequested ? "docker-readonly" : "host");
+    overrides.sandboxMode || args.sandboxMode || process.env.SANDBOX_MODE || (dockerRequested ? "docker-workspace" : "host");
   const sandboxMode = normalizeSandboxMode(requestedSandboxMode);
 
   return {
@@ -65,14 +65,14 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     apiKey: overrides.apiKey || defaults.apiKey,
     baseURL: overrides.baseURL || defaults.baseURL,
     model: route.model || defaults.model,
-    maxSteps: parseNumber(overrides.maxSteps ?? args.maxSteps ?? process.env.MAX_STEPS, 15),
+    maxSteps: parseNumber(overrides.maxSteps ?? args.maxSteps ?? process.env.MAX_STEPS, 24),
     headless: parseBoolean(overrides.headless ?? args.headless ?? process.env.HEADLESS, false),
     allowedDomains: Array.isArray(overrides.allowedDomains)
       ? overrides.allowedDomains
       : parseList(process.env.ALLOWED_DOMAINS),
     allowPasswords: parseBoolean(overrides.allowPasswords ?? process.env.ALLOW_PASSWORDS, false),
     allowDestructive: parseBoolean(overrides.allowDestructive ?? args.allowDestructive ?? process.env.ALLOW_DESTRUCTIVE, false),
-    allowShellTool: parseBoolean(overrides.allowShellTool ?? args.allowShellTool ?? process.env.ALLOW_SHELL_TOOL, false),
+    allowShellTool: parseBoolean(overrides.allowShellTool ?? args.allowShellTool ?? process.env.ALLOW_SHELL_TOOL, true),
     allowFileTools: parseBoolean(overrides.allowFileTools ?? args.allowFileTools ?? process.env.ALLOW_FILE_TOOLS, true),
     allowWrapperTools: parseBoolean(
       overrides.allowWrapperTools ?? args.allowWrapperTools ?? process.env.ALLOW_WRAPPER_TOOLS,
@@ -84,9 +84,9 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     wrapperTimeoutMs: parseNumber(overrides.wrapperTimeoutMs ?? process.env.WRAPPER_TIMEOUT_MS, 120000),
     sandboxMode,
     packageInstallPolicy: normalizePackageInstallPolicy(
-      overrides.packageInstallPolicy || args.packageInstallPolicy || process.env.PACKAGE_INSTALL_POLICY || "prompt"
+      overrides.packageInstallPolicy || args.packageInstallPolicy || process.env.PACKAGE_INSTALL_POLICY || (sandboxMode === "host" ? "prompt" : "allow")
     ),
-    useDockerSandbox: sandboxMode !== "host" || dockerRequested,
+    useDockerSandbox: sandboxMode !== "host",
     dockerSandboxImage: overrides.dockerSandboxImage || process.env.DOCKER_SANDBOX_IMAGE || "agintiflow-sandbox:latest",
     commandCwd: path.resolve(overrides.commandCwd || args.commandCwd || process.env.COMMAND_CWD || baseDir),
     sessionsDir: path.resolve(baseDir, ".sessions"),

package/src/docker-sandbox.js

@@ -1,5 +1,6 @@
 import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { execFile as execFileCallback } from "node:child_process";
 import { promisify } from "node:util";
@@ -8,6 +9,9 @@ import { redactSensitiveText, redactValue } from "./redaction.js";
 
 const execFile = promisify(execFileCallback);
 const DOCKER_WORKSPACE = "/workspace";
+const DOCKER_HOME = "/aginti-home";
+const DOCKER_CACHE = "/aginti-cache";
+const DOCKER_ENV = "/aginti-env";
 const READY_IMAGES = new Set();
 const SANDBOX_LOG_LIMIT = 80;
 const sandboxLogs = [];
@@ -101,10 +105,31 @@ function sandboxDockerfilePath(config) {
   return path.join(sandboxPackageDir(config), "docker", "sandbox.Dockerfile");
 }
 
+function persistentDockerDirs(config) {
+  const root = path.resolve(
+    config.dockerStateDir || process.env.AGINTIFLOW_DOCKER_STATE_DIR || path.join(os.homedir(), ".agintiflow", "docker")
+  );
+  return {
+    root,
+    home: path.join(root, "home"),
+    cache: path.join(root, "cache"),
+    env: path.join(root, "env"),
+  };
+}
+
+async function ensurePersistentDockerDirs(config) {
+  const dirs = persistentDockerDirs(config);
+  await Promise.all([fs.mkdir(dirs.home, { recursive: true }), fs.mkdir(dirs.cache, { recursive: true }), fs.mkdir(dirs.env, { recursive: true })]);
+  return dirs;
+}
+
 export async function getDockerSandboxStatus(config) {
   const image = config.dockerSandboxImage;
   const dockerfilePath = sandboxDockerfilePath(config);
   const workspace = config.commandCwd;
+  if (config.useDockerSandbox) {
+    await ensurePersistentDockerDirs(config).catch(() => null);
+  }
   const [dockerReady, dockerfileExists, workspaceExists, workspaceReadable, workspaceWritable] = await Promise.all([
     dockerAvailable(),
     pathAccess(dockerfilePath, fsConstants.R_OK),
@@ -114,6 +139,12 @@ export async function getDockerSandboxStatus(config) {
   ]);
 
   const imageReady = dockerReady ? await dockerImageExists(image) : false;
+  const persistentDirs = persistentDockerDirs(config);
+  const [persistentHomeExists, persistentCacheExists, persistentEnvExists] = await Promise.all([
+    pathAccess(persistentDirs.home, fsConstants.F_OK),
+    pathAccess(persistentDirs.cache, fsConstants.F_OK),
+    pathAccess(persistentDirs.env, fsConstants.F_OK),
+  ]);
   return {
     sandboxMode: normalizeSandboxMode(config.sandboxMode),
     useDockerSandbox: Boolean(config.useDockerSandbox),
@@ -127,6 +158,18 @@ export async function getDockerSandboxStatus(config) {
     workspaceReadable,
     workspaceWritable,
     dockerfileExists,
+    persistentDocker: {
+      home: persistentDirs.home,
+      cache: persistentDirs.cache,
+      env: persistentDirs.env,
+      homeExists: persistentHomeExists,
+      cacheExists: persistentCacheExists,
+      envExists: persistentEnvExists,
+      containerHome: DOCKER_HOME,
+      containerCache: DOCKER_CACHE,
+      containerEnv: DOCKER_ENV,
+      pythonVenv: `${DOCKER_ENV}/python`,
+    },
     logs: getSandboxLogs(),
   };
 }
@@ -165,7 +208,30 @@ export async function ensureDockerSandboxReady(config, observers, options = {})
   await buildDockerSandboxImage(config, observers);
 }
 
-function dockerRunArgs(command, config, policy = evaluateCommandPolicy(command, config)) {
+function dockerCommand(command, policy) {
+  const envLines = [
+    `export HOME=${DOCKER_HOME}`,
+    `export XDG_CACHE_HOME=${DOCKER_CACHE}`,
+    `export PIP_CACHE_DIR=${DOCKER_CACHE}/pip`,
+    `export UV_CACHE_DIR=${DOCKER_CACHE}/uv`,
+    `export NPM_CONFIG_CACHE=${DOCKER_CACHE}/npm`,
+    `export CONDA_PKGS_DIRS=${DOCKER_CACHE}/conda-pkgs`,
+    `export PYTHONUSERBASE=${DOCKER_ENV}/python-user`,
+    `export PATH=${DOCKER_ENV}/python/bin:${DOCKER_ENV}/python-user/bin:${DOCKER_ENV}/miniforge/bin:${DOCKER_ENV}/bin:$PATH`,
+    `cd ${DOCKER_WORKSPACE}`,
+  ];
+
+  if (!policy.requiresDockerRoot) {
+    envLines.push(
+      `if command -v python3 >/dev/null 2>&1 && [ ! -x ${DOCKER_ENV}/python/bin/python ]; then python3 -m venv --system-site-packages ${DOCKER_ENV}/python >/dev/null 2>&1 || true; fi`,
+      `if [ -f ${DOCKER_ENV}/python/bin/activate ]; then . ${DOCKER_ENV}/python/bin/activate; fi`
+    );
+  }
+
+  return [...envLines, String(command)].join("\n");
+}
+
+function dockerRunArgs(command, config, policy = evaluateCommandPolicy(command, config), persistentDirs = persistentDockerDirs(config)) {
   const uid = typeof process.getuid === "function" ? String(process.getuid()) : "";
   const gid = typeof process.getgid === "function" ? String(process.getgid()) : "";
   const userArgs = uid && gid && !policy.requiresDockerRoot ? ["--user", `${uid}:${gid}`] : [];
@@ -196,24 +262,29 @@ function dockerRunArgs(command, config, policy = evaluateCommandPolicy(command,
     ...readOnlyArgs,
     ...userArgs,
     "-e",
-    "HOME=/tmp",
-    "-e",
     "NPM_CONFIG_USERCONFIG=/tmp/.npmrc",
     "-e",
     "PIP_DISABLE_PIP_VERSION_CHECK=1",
     "-v",
     `${config.commandCwd}:${DOCKER_WORKSPACE}:${mountMode}`,
+    "-v",
+    `${persistentDirs.home}:${DOCKER_HOME}:rw`,
+    "-v",
+    `${persistentDirs.cache}:${DOCKER_CACHE}:rw`,
+    "-v",
+    `${persistentDirs.env}:${DOCKER_ENV}:rw`,
     "-w",
     DOCKER_WORKSPACE,
     config.dockerSandboxImage,
     "bash",
     "-lc",
-    String(command),
+    dockerCommand(command, policy),
   ];
 }
 
 export async function runDockerSandboxCommand(command, config, policy = evaluateCommandPolicy(command, config)) {
-  const result = await execDocker(dockerRunArgs(command, config, policy), {
+  const persistentDirs = await ensurePersistentDockerDirs(config);
+  const result = await execDocker(dockerRunArgs(command, config, policy, persistentDirs), {
     timeout: policy.needsNetwork ? 120000 : policy.category === "toolchain" ? 90000 : 15000,
     maxBuffer: 300 * 1024,
   });
@@ -227,6 +298,7 @@ export async function runDockerSandboxCommand(command, config, policy = evaluate
     category: policy.category,
     sandboxMode: policy.sandboxMode,
     network: policy.needsNetwork ? "bridge" : "none",
+    persistentDocker: persistentDirs,
     stdout: payload.stdout.slice(0, 1200),
     stderr: payload.stderr.slice(0, 1200),
   });
@@ -274,6 +346,7 @@ export async function runDockerPreflight(config, options = {}) {
 
   let status = await getDockerSandboxStatus(config);
   const runChecks = async () => {
+    const persistentDirs = await ensurePersistentDockerDirs(config);
     const results = [];
     for (const command of [
       "node -v",
@@ -287,7 +360,7 @@ export async function runDockerPreflight(config, options = {}) {
       "rg --version",
     ]) {
       try {
-        const result = await execDocker(dockerRunArgs(command, config, { needsNetwork: false, category: "preflight" }), {
+        const result = await execDocker(dockerRunArgs(command, config, { needsNetwork: false, category: "preflight" }, persistentDirs), {
           timeout: 15000,
           maxBuffer: 100 * 1024,
         });

package/src/interactive-cli.js

@@ -0,0 +1,241 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { runAgent } from "./agent-runner.js";
+import { loadConfig } from "./config.js";
+import { initProject, listProjectSessions } from "./project.js";
+import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./command-policy.js";
+import { normalizeTaskProfile } from "./task-profiles.js";
+
+function printHelp() {
+  console.log(
+    [
+      "Commands:",
+      "  /help                     Show this help.",
+      "  /status                   Show active route, workspace, sandbox, and session.",
+      "  /new                      Start a fresh session on the next message.",
+      "  /resume <session-id>      Continue a saved session.",
+      "  /sessions                 List recent sessions in this project.",
+      "  /profile <name>           Set task profile, e.g. code, website, latex, maintenance.",
+      "  /routing <mode>           Set routing: smart, fast, complex, manual.",
+      "  /provider <name>          Set provider: deepseek, openai, mock.",
+      "  /model <name>             Set an explicit model, or /model auto.",
+      "  /docker on                Use docker-workspace with approved package installs.",
+      "  /docker off               Use host shell policy.",
+      "  /latex on                 Use the LaTeX/PDF profile in Docker with a larger step budget.",
+      "  /installs block|prompt|allow",
+      "  /cwd <path>               Change command workspace.",
+      "  /exit                     Quit.",
+      "",
+      "Type a normal request to run the agent. Example: write a Python CLI app with tests",
+    ].join("\n")
+  );
+}
+
+function printStatus(state) {
+  console.log(`project=${process.cwd()}`);
+  console.log(`cwd=${state.commandCwd || process.cwd()}`);
+  console.log(`session=${state.sessionId || "new"}`);
+  console.log(`provider=${state.provider || "auto"} routing=${state.routingMode} model=${state.model || "auto"}`);
+  console.log(`profile=${state.taskProfile} maxSteps=${state.maxSteps}`);
+  console.log(
+    `shell=${state.allowShellTool} files=${state.allowFileTools} sandbox=${state.sandboxMode} installs=${state.packageInstallPolicy}`
+  );
+  if (state.sandboxMode !== "host") {
+    console.log(`dockerWorkspace=/workspace -> ${state.commandCwd || process.cwd()}`);
+  }
+}
+
+function createState(args = {}) {
+  return {
+    provider: args.provider || "",
+    model: args.model || "",
+    routingMode: args.routingMode || "smart",
+    commandCwd: args.commandCwd || process.cwd(),
+    sandboxMode: normalizeSandboxMode(args.sandboxMode || "docker-workspace"),
+    packageInstallPolicy: normalizePackageInstallPolicy(args.packageInstallPolicy || "allow"),
+    allowShellTool: args.allowShellTool ?? true,
+    allowFileTools: args.allowFileTools ?? true,
+    allowWrapperTools: args.allowWrapperTools ?? false,
+    allowDestructive: args.allowDestructive ?? false,
+    preferredWrapper: args.preferredWrapper || "codex",
+    taskProfile: normalizeTaskProfile(args.taskProfile || "auto"),
+    headless: args.headless ?? false,
+    maxSteps: Number.isFinite(args.maxSteps) && args.maxSteps > 0 ? args.maxSteps : args.latex ? 30 : 24,
+    sessionId: args.resume || "",
+  };
+}
+
+async function handleCommand(line, state, packageDir) {
+  const [command, ...rest] = line.slice(1).trim().split(/\s+/);
+  const value = rest.join(" ").trim();
+
+  if (!command || command === "help" || command === "?") {
+    printHelp();
+    return true;
+  }
+  if (command === "exit" || command === "quit" || command === "q") return false;
+  if (command === "status") {
+    printStatus(state);
+    return true;
+  }
+  if (command === "new") {
+    state.sessionId = "";
+    console.log("Next message will start a new session.");
+    return true;
+  }
+  if (command === "resume") {
+    if (!value) console.log("Usage: /resume <session-id>");
+    else {
+      state.sessionId = value;
+      console.log(`Resuming ${state.sessionId}`);
+    }
+    return true;
+  }
+  if (command === "sessions") {
+    const sessions = await listProjectSessions(process.cwd(), 20);
+    if (sessions.length === 0) console.log("No project-local sessions found.");
+    else {
+      for (const session of sessions) {
+        const goal = session.goal ? ` ${session.goal.slice(0, 80)}` : "";
+        console.log(`${session.sessionId} ${session.provider}/${session.model} ${session.updatedAt}${goal}`);
+      }
+    }
+    return true;
+  }
+  if (command === "profile") {
+    state.taskProfile = normalizeTaskProfile(value || "auto");
+    console.log(`profile=${state.taskProfile}`);
+    return true;
+  }
+  if (command === "routing") {
+    state.routingMode = value || "smart";
+    console.log(`routing=${state.routingMode}`);
+    return true;
+  }
+  if (command === "provider") {
+    state.provider = value === "auto" ? "" : value;
+    console.log(`provider=${state.provider || "auto"}`);
+    return true;
+  }
+  if (command === "model") {
+    state.model = value === "auto" ? "" : value;
+    console.log(`model=${state.model || "auto"}`);
+    return true;
+  }
+  if (command === "installs") {
+    state.packageInstallPolicy = normalizePackageInstallPolicy(value || "prompt");
+    console.log(`installs=${state.packageInstallPolicy}`);
+    return true;
+  }
+  if (command === "docker") {
+    if (value === "on") {
+      state.sandboxMode = "docker-workspace";
+      state.packageInstallPolicy = "allow";
+      console.log(`docker=on /workspace -> ${state.commandCwd || process.cwd()} installs=allow`);
+    } else if (value === "off") {
+      state.sandboxMode = "host";
+      state.packageInstallPolicy = "prompt";
+      console.log("docker=off sandbox=host installs=prompt");
+    } else {
+      console.log("Usage: /docker on OR /docker off");
+    }
+    return true;
+  }
+  if (command === "latex") {
+    if (value === "on" || value === "") {
+      state.taskProfile = "latex";
+      state.sandboxMode = "docker-workspace";
+      state.packageInstallPolicy = "allow";
+      state.maxSteps = Math.max(state.maxSteps, 30);
+      console.log("latex=on profile=latex sandbox=docker-workspace installs=allow maxSteps=30");
+    } else if (value === "off") {
+      state.taskProfile = "auto";
+      console.log("latex=off profile=auto");
+    } else {
+      console.log("Usage: /latex on OR /latex off");
+    }
+    return true;
+  }
+  if (command === "cwd") {
+    state.commandCwd = value || process.cwd();
+    console.log(`cwd=${state.commandCwd}`);
+    return true;
+  }
+  if (command === "init") {
+    const result = await initProject(process.cwd());
+    console.log(`initialized project=${result.projectRoot}`);
+    return true;
+  }
+  if (command === "web") {
+    const port = value || "3220";
+    console.log(`Run in another terminal: aginti web --port ${port}`);
+    return true;
+  }
+
+  console.log(`Unknown command: /${command}. Use /help.`);
+  return true;
+}
+
+async function runPrompt(prompt, state, packageDir) {
+  const config = loadConfig(
+    {
+      provider: state.provider,
+      model: state.model,
+      routingMode: state.routingMode,
+      commandCwd: state.commandCwd,
+      sandboxMode: state.sandboxMode,
+      packageInstallPolicy: state.packageInstallPolicy,
+      allowShellTool: state.allowShellTool,
+      allowFileTools: state.allowFileTools,
+      allowWrapperTools: state.allowWrapperTools,
+      allowDestructive: state.allowDestructive,
+      preferredWrapper: state.preferredWrapper,
+      taskProfile: state.taskProfile,
+      maxSteps: state.maxSteps,
+      headless: state.headless,
+      resume: state.sessionId,
+      goal: prompt,
+    },
+    { packageDir, baseDir: process.cwd() }
+  );
+
+  const result = await runAgent(config);
+  state.sessionId = result.sessionId || state.sessionId;
+}
+
+export async function startInteractiveCli(args = {}, { packageDir, packageVersion } = {}) {
+  const state = createState(args);
+  const rl = readline.createInterface({ input, output, terminal: Boolean(input.isTTY && output.isTTY) });
+
+  console.log(`AgInTiFlow ${packageVersion || ""}`.trim());
+  console.log(`Project: ${process.cwd()}`);
+  console.log("Interactive agent chat. Type /help for commands, /exit to quit.");
+  printStatus(state);
+
+  try {
+    while (true) {
+      let answer = "";
+      try {
+        answer = await rl.question("\naginti> ");
+      } catch (error) {
+        if (error?.code === "ERR_USE_AFTER_CLOSE") break;
+        throw error;
+      }
+      const line = answer.trim();
+      if (!line) continue;
+      if (line.startsWith("/")) {
+        const keepGoing = await handleCommand(line, state, packageDir);
+        if (!keepGoing) break;
+        continue;
+      }
+
+      try {
+        await runPrompt(line, state, packageDir);
+      } catch (error) {
+        console.error(`error: ${error.message}`);
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}