@mandipadk7/kavi 1.0.0 → 1.0.1

package/README.md

@@ -9,8 +9,8 @@ Current capabilities:
 - `kavi init --no-commit`: skip the bootstrap commit and let `kavi open` or `kavi start` create the first base commit later.
 - `kavi doctor`: verify Node, Codex, Claude, git worktree support, and local readiness.
 - `kavi update`: check for and install a newer published Kavi package from npm.
-- `kavi start`: start a managed session without attaching the TUI.
-- `kavi open`: create a managed session with separate Codex and Claude worktrees and open the full-screen operator console, even from an empty folder or a repo with no `HEAD` yet.
+- `kavi start`: start a managed session without attaching the TUI. Add `--approve-all` to run future Codex and Claude turns with full access and without Kavi approval prompts.
+- `kavi open`: create a managed session with separate Codex and Claude worktrees and open the full-screen operator console, even from an empty folder or a repo with no `HEAD` yet. Add `--approve-all` to start in full-access mode.
 - `kavi resume`: reopen the operator console for the current repo session.
 - `kavi summary`: show a cohesive session-level view of progress, current changes, recent activity, and landing readiness.
 - `kavi result`: show the current or latest landed outcome as one cohesive result surface, including per-agent output and merged landing details.
@@ -52,12 +52,13 @@ Notes:
 - `kavi init` and `kavi open` now support the "empty folder to first managed session" path. If no git repo exists, Kavi initializes one; if git exists but no `HEAD` exists yet, Kavi creates the bootstrap commit it needs for worktrees.
 - Codex runs through `codex app-server` in managed mode, so Codex-side approvals now land in the same Kavi inbox as Claude hook approvals.
 - Claude still runs through the installed `claude` CLI with Kavi-managed hooks and approval decisions.
+- `--approve-all` and the operator console's `!` toggle switch Kavi into a full-access mode for future turns. In that mode, Claude runs with `--dangerously-skip-permissions`, Codex runs with its no-approval danger-full-access equivalent, and Kavi stops prompting for approvals on those future turns.
 - `kavi doctor` now checks Claude auth readiness with `claude auth status`, and startup blocks if Claude is installed but not authenticated.
 - `kavi doctor` also validates ownership path rules for duplicates, repo escapes, and absolute-path mistakes before those rules affect routing.
 - `kavi doctor` now also flags overlapping cross-agent ownership rules that do not produce a clear specificity winner.
 - The dashboard and operator commands now use the daemon's local RPC socket instead of editing session files directly, and the TUI stays updated from pushed daemon snapshots rather than polling.
 - The socket is machine-local rather than repo-local to avoid Unix socket path-length issues in deep repos and temp directories.
-- The console is keyboard-driven: `1-9` switch views, `j/k` move selection, `[` and `]` cycle task detail sections, `,` and `.` cycle changed files, `{` and `}` cycle patch hunks, `A/C/Q/M` add review notes, `o/O` cycle existing threads, `T` reply, `E` edit, `R` resolve or reopen, `a` cycle thread assignee, `w` mark a thread as won't-fix, `x` mark it as accepted-risk, `F` queue a fix task, `H` queue a handoff task, `y/n` resolve approvals, and `c` opens the inline task composer with live route preview diagnostics.
+- The console is keyboard-driven: `1-9` switch views, `j/k` move selection, `[` and `]` cycle task detail sections, `,` and `.` cycle changed files, `{` and `}` cycle patch hunks, `A/C/Q/M` add review notes, `o/O` cycle existing threads, `T` reply, `E` edit, `R` resolve or reopen, `a` cycle thread assignee, `w` mark a thread as won't-fix, `x` mark it as accepted-risk, `F` queue a fix task, `H` queue a handoff task, `y/n` resolve approvals, `!` toggles full-access mode, and `c` opens the inline task composer with live route preview diagnostics. Inside the composer, digits are treated as literal text and `Tab` cycles the route owner.
 - Review filters are available both in the CLI and the TUI: `kavi reviews --assignee operator --status open`, and inside the console use `u`, `v`, and `d` to cycle assignee, status, and disposition filters for the active diff context.
 - The claims inspector now shows active overlap hotspots and ownership-rule conflicts so routing pressure points are visible directly in the operator surface.
 - The claims and decision inspectors now also show recommendation-driven next actions, so hotspots, cross-agent review pressure, and ownership-config problems can be turned into follow-up tasks directly from the operator surface.
@@ -65,7 +66,7 @@ Notes:
 - Review threads now carry explicit assignees and richer dispositions, including `accepted risk` and `won't fix`, instead of relying only on free-form note text.
 - Successful follow-up tasks now auto-resolve linked open review threads, landed follow-up work marks those resolved threads as landed, and replying to a resolved thread reopens it.
 - `kavi update --check` reports newer published builds without installing them, and `kavi update` can apply a chosen `latest`, `beta`, or exact version after confirmation.
-- The operator console now includes a dedicated recommendations view. Use `8` to switch there, `Enter` to apply a recommendation, `P` to force an additional follow-up task when one is already open, `z` to dismiss, and `Z` to restore.
+- The operator console now includes a dedicated recommendations view. Use `4` to switch there, `Enter` to apply a recommendation, `P` to force an additional follow-up task when one is already open, `z` to dismiss, and `Z` to restore.
 - `kavi land` now prints a clearer merged-result summary, including the pre-land change surface by agent, validation status, and how many review threads were landed as part of the merge.
 - After `kavi land`, run `kavi result` to inspect the persisted merged-result report and the latest per-agent outcome in one place.
 

package/dist/adapters/claude.js

@@ -135,9 +135,33 @@ export async function writeClaudeSettings(paths, session) {
             "--event",
             event
         ]);
+    const toolHooks = session.fullAccessMode ? {} : {
+        PreToolUse: [
+            {
+                matcher: "Bash|Edit|Write|MultiEdit",
+                hooks: [
+                    {
+                        type: "command",
+                        command: buildHookCommand("PreToolUse")
+                    }
+                ]
+            }
+        ],
+        PostToolUse: [
+            {
+                matcher: "Bash|Edit|Write|MultiEdit",
+                hooks: [
+                    {
+                        type: "command",
+                        command: buildHookCommand("PostToolUse")
+                    }
+                ]
+            }
+        ]
+    };
     const settings = {
         permissions: {
-            defaultMode: "plan"
+            defaultMode: session.fullAccessMode ? "bypassPermissions" : "plan"
         },
         hooks: {
             SessionStart: [
@@ -151,28 +175,7 @@ export async function writeClaudeSettings(paths, session) {
                     ]
                 }
             ],
-            PreToolUse: [
-                {
-                    matcher: "Bash|Edit|Write|MultiEdit",
-                    hooks: [
-                        {
-                            type: "command",
-                            command: buildHookCommand("PreToolUse")
-                        }
-                    ]
-                }
-            ],
-            PostToolUse: [
-                {
-                    matcher: "Bash|Edit|Write|MultiEdit",
-                    hooks: [
-                        {
-                            type: "command",
-                            command: buildHookCommand("PostToolUse")
-                        }
-                    ]
-                }
-            ],
+            ...toolHooks,
             Notification: [
                 {
                     matcher: "permission_prompt|idle_prompt|auth_success",
@@ -205,6 +208,34 @@ export async function writeClaudeSettings(paths, session) {
 export function resolveClaudeSessionId(session) {
     return session.agentStatus.claude.sessionId ?? session.id;
 }
+export function buildClaudeCommandArgs(session, claudeSessionId, prompt, settingsPath) {
+    const sessionArgs = session.agentStatus.claude.sessionId ? [
+        "--resume",
+        claudeSessionId
+    ] : [
+        "--session-id",
+        claudeSessionId
+    ];
+    return [
+        "-p",
+        "--output-format",
+        "json",
+        "--json-schema",
+        CLAUDE_ENVELOPE_SCHEMA,
+        "--settings",
+        settingsPath,
+        ...session.fullAccessMode ? [
+            "--permission-mode",
+            "bypassPermissions",
+            "--dangerously-skip-permissions"
+        ] : [
+            "--permission-mode",
+            "plan"
+        ],
+        ...sessionArgs,
+        prompt
+    ];
+}
 export async function runClaudeTask(session, task, paths) {
     const worktree = findWorktree(session, "claude");
     const claudeSessionId = resolveClaudeSessionId(session);
@@ -215,25 +246,7 @@ export async function runClaudeTask(session, task, paths) {
         "",
         buildTaskPrompt(session, task, "claude")
     ].join("\n");
-    const result = await runCommand(session.runtime.claudeExecutable, [
-        "-p",
-        "--output-format",
-        "json",
-        "--json-schema",
-        CLAUDE_ENVELOPE_SCHEMA,
-        "--settings",
-        paths.claudeSettingsFile,
-        "--permission-mode",
-        "plan",
-        ...session.agentStatus.claude.sessionId ? [
-            "--resume",
-            claudeSessionId
-        ] : [
-            "--session-id",
-            claudeSessionId
-        ],
-        prompt
-    ], {
+    const result = await runCommand(session.runtime.claudeExecutable, buildClaudeCommandArgs(session, claudeSessionId, prompt, paths.claudeSettingsFile), {
         cwd: worktree.path
     });
     const rawOutput = result.code === 0 ? result.stdout : `${result.stdout}\n${result.stderr}`;

package/dist/adapters/codex.js

@@ -128,19 +128,41 @@ function buildApprovalResponse(method, params, approved, remember) {
             throw new Error(`Unsupported Codex approval request: ${method}`);
     }
 }
-function buildThreadParams(session, worktree, developerInstructions) {
+export function buildThreadParams(session, worktree, developerInstructions) {
     const configuredModel = session.config.agents.codex.model.trim();
     return {
         cwd: worktree.path,
-        approvalPolicy: "on-request",
-        approvalsReviewer: "user",
-        sandbox: "workspace-write",
+        approvalPolicy: session.fullAccessMode ? "never" : "on-request",
+        sandbox: session.fullAccessMode ? "danger-full-access" : "workspace-write",
         baseInstructions: "You are Codex inside Kavi. Operate inside the assigned worktree and keep work task-scoped.",
         developerInstructions,
         model: configuredModel || null,
         ephemeral: false,
         experimentalRawEvents: false,
-        persistExtendedHistory: true
+        persistExtendedHistory: true,
+        ...session.fullAccessMode ? {} : {
+            approvalsReviewer: "user"
+        }
+    };
+}
+export function buildCodexTurnParams(session, worktree, threadId, inputText) {
+    return {
+        threadId,
+        cwd: worktree.path,
+        approvalPolicy: session.fullAccessMode ? "never" : "on-request",
+        sandbox: session.fullAccessMode ? "danger-full-access" : "workspace-write",
+        model: session.config.agents.codex.model.trim() || null,
+        outputSchema: ENVELOPE_OUTPUT_SCHEMA,
+        input: [
+            {
+                type: "text",
+                text: inputText,
+                text_elements: []
+            }
+        ],
+        ...session.fullAccessMode ? {} : {
+            approvalsReviewer: "user"
+        }
     };
 }
 async function ensureThread(client, session, paths, worktree, developerInstructions) {
@@ -163,6 +185,16 @@ async function ensureThread(client, session, paths, worktree, developerInstructi
 }
 async function handleCodexApproval(session, paths, request) {
     const descriptor = describeCodexApprovalRequest(request.method, request.params);
+    if (session.fullAccessMode) {
+        await recordEvent(paths, session.id, "approval.full_access_bypassed", {
+            agent: "codex",
+            requestId: request.id,
+            method: request.method,
+            toolName: descriptor.toolName,
+            summary: descriptor.summary
+        });
+        return buildApprovalResponse(request.method, request.params, true, true);
+    }
     const rule = await findApprovalRule(paths, {
         repoRoot: session.repoRoot,
         agent: "codex",
@@ -218,21 +250,7 @@ export async function runCodexTask(session, task, paths) {
     try {
         await client.initialize();
         const threadId = await ensureThread(client, session, paths, worktree, developerInstructions);
-        const result = await client.runTurn({
-            threadId,
-            cwd: worktree.path,
-            approvalPolicy: "on-request",
-            approvalsReviewer: "user",
-            model: session.config.agents.codex.model.trim() || null,
-            outputSchema: ENVELOPE_OUTPUT_SCHEMA,
-            input: [
-                {
-                    type: "text",
-                    text: buildTaskPrompt(session, task, "codex"),
-                    text_elements: []
-                }
-            ]
-        });
+        const result = await client.runTurn(buildCodexTurnParams(session, worktree, threadId, buildTaskPrompt(session, task, "codex")));
         const rawOutput = `${result.assistantMessage}${result.stderr ? `\n\n[stderr]\n${result.stderr}` : ""}`;
         const envelope = extractJsonObject(result.assistantMessage);
         return {

package/dist/codex-app-server.js

@@ -1,4 +1,11 @@
 import { spawn } from "node:child_process";
+export function buildCodexAppServerArgs() {
+    return [
+        "app-server",
+        "--listen",
+        "stdio://"
+    ];
+}
 function asObject(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -29,13 +36,7 @@ export class CodexAppServerClient {
     closePromise = null;
     constructor(runtime, cwd, onRequest){
         this.onRequest = onRequest;
-        this.child = spawn(runtime.codexExecutable, [
-            "app-server",
-            "--listen",
-            "stdio://",
-            "--session-source",
-            "cli"
-        ], {
+        this.child = spawn(runtime.codexExecutable, buildCodexAppServerArgs(), {
             cwd,
             stdio: [
                 "pipe",

package/dist/daemon.js

@@ -201,6 +201,13 @@ export class KaviDaemon {
                         ok: true
                     }
                 };
+            case "setFullAccessMode":
+                await this.setFullAccessModeFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
             case "taskArtifact":
                 return {
                     result: await this.getTaskArtifactFromRpc(params)
@@ -445,6 +452,29 @@ export class KaviDaemon {
             await this.publishSnapshot("approval.resolved");
         });
     }
+    async setFullAccessModeFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const enabled = params.enabled === true;
+            if (this.session.fullAccessMode === enabled) {
+                return;
+            }
+            this.session.fullAccessMode = enabled;
+            addDecisionRecord(this.session, {
+                kind: "approval",
+                agent: null,
+                summary: `${enabled ? "Enabled" : "Disabled"} approve-all mode`,
+                detail: enabled ? "Future Claude and Codex turns will run with full access and without Kavi approval prompts." : "Future Claude and Codex turns will return to standard approval and sandbox behavior.",
+                metadata: {
+                    enabled
+                }
+            });
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "session.full_access_mode_changed", {
+                enabled
+            });
+            await this.publishSnapshot("session.full_access_mode_changed");
+        });
+    }
     async getTaskArtifactFromRpc(params) {
         const taskId = typeof params.taskId === "string" ? params.taskId : "";
         if (!taskId) {

package/dist/main.js

@@ -15,7 +15,7 @@ import { loadPackageInfo } from "./package-info.js";
 import { buildSessionId, resolveAppPaths } from "./paths.js";
 import { isProcessAlive, runCommand, runInteractiveCommand, spawnDetachedNode } from "./process.js";
 import { buildLandReport, loadLatestLandReport, saveLandReport } from "./reports.js";
-import { pingRpc, readSnapshot, rpcDismissRecommendation, rpcEnqueueTask, rpcNotifyExternalUpdate, rpcKickoff, rpcRecentEvents, rpcResolveApproval, rpcRestoreRecommendation, rpcShutdown, rpcTaskArtifact } from "./rpc.js";
+import { pingRpc, readSnapshot, rpcDismissRecommendation, rpcEnqueueTask, rpcNotifyExternalUpdate, rpcKickoff, rpcRecentEvents, rpcResolveApproval, rpcSetFullAccessMode, rpcRestoreRecommendation, rpcShutdown, rpcTaskArtifact } from "./rpc.js";
 import { buildOperatorRecommendations, buildRecommendationActionPlan, dismissOperatorRecommendation, restoreOperatorRecommendation } from "./recommendations.js";
 import { findOwnershipRuleConflicts } from "./ownership.js";
 import { filterReviewNotes, markReviewNotesLandedForTasks } from "./reviews.js";
@@ -33,6 +33,9 @@ const CLAUDE_AUTO_ALLOW_TOOLS = new Set([
     "Grep",
     "LS"
 ]);
+function hasFlag(args, name) {
+    return args.includes(name);
+}
 function getFlag(args, name) {
     const index = args.indexOf(name);
     if (index === -1) {
@@ -112,8 +115,8 @@ function renderUsage() {
         "  kavi init [--home] [--no-commit]",
         "  kavi doctor [--json]",
         "  kavi update [--check] [--dry-run] [--yes] [--tag latest|beta] [--version X.Y.Z]",
-        "  kavi start [--goal \"...\"]",
-        "  kavi open [--goal \"...\"]",
+        "  kavi start [--goal \"...\"] [--approve-all]",
+        "  kavi open [--goal \"...\"] [--approve-all]",
         "  kavi resume",
         "  kavi summary [--json]",
         "  kavi result [--json]",
@@ -360,7 +363,10 @@ async function commandUpdate(cwd, args) {
     }
     console.log(`Updated ${packageInfo.name} from ${packageInfo.version} to ${targetVersion}.`);
 }
-async function startOrAttachSession(cwd, goal) {
+function renderFullAccessWarning() {
+    return "WARNING: approve-all is enabled. Claude and Codex will run with full access, and Kavi approval prompts will be bypassed for future turns.";
+}
+async function startOrAttachSession(cwd, goal, enableFullAccessMode) {
     const prepared = await prepareProjectContext(cwd, {
         createRepository: true,
         ensureHeadCommit: false,
@@ -371,6 +377,11 @@ async function startOrAttachSession(cwd, goal) {
         try {
             const session = await loadSessionRecord(paths);
             if (isSessionLive(session) && await pingRpc(paths)) {
+                if (enableFullAccessMode && !session.fullAccessMode) {
+                    await rpcSetFullAccessMode(paths, {
+                        enabled: true
+                    });
+                }
                 if (goal) {
                     await rpcKickoff(paths, goal);
                 }
@@ -391,7 +402,7 @@ async function startOrAttachSession(cwd, goal) {
     const rpcEndpoint = paths.socketPath;
     await fs.writeFile(paths.commandsFile, "", "utf8");
     const worktrees = await ensureWorktrees(repoRoot, paths, sessionId, config, baseCommit);
-    await createSessionRecord(paths, config, runtime, sessionId, baseCommit, worktrees, goal, rpcEndpoint);
+    await createSessionRecord(paths, config, runtime, sessionId, baseCommit, worktrees, goal, rpcEndpoint, enableFullAccessMode);
     if (prepared.createdRepository) {
         await recordEvent(paths, sessionId, "repo.initialized", {
             repoRoot
@@ -502,9 +513,13 @@ function buildRouteAnalytics(tasks) {
 }
 async function commandOpen(cwd, args) {
     const goal = getGoal(args);
-    await startOrAttachSession(cwd, goal);
+    await startOrAttachSession(cwd, goal, hasFlag(args, "--approve-all"));
     const repoRoot = await detectRepoRoot(cwd);
     const paths = resolveAppPaths(repoRoot);
+    const session = await loadSessionRecord(paths);
+    if (session.fullAccessMode) {
+        console.log(renderFullAccessWarning());
+    }
     await attachTui(paths);
 }
 async function commandResume(cwd) {
@@ -514,14 +529,18 @@ async function commandResume(cwd) {
 }
 async function commandStart(cwd, args) {
     const goal = getGoal(args);
-    const socketPath = await startOrAttachSession(cwd, goal);
+    const socketPath = await startOrAttachSession(cwd, goal, hasFlag(args, "--approve-all"));
     const repoRoot = await detectRepoRoot(cwd);
     const paths = resolveAppPaths(repoRoot);
     const session = await loadSessionRecord(paths);
     console.log(`Started Kavi session ${session.id}`);
     console.log(`Repo: ${repoRoot}`);
     console.log(`Control: ${socketPath}`);
+    console.log(`Access: ${session.fullAccessMode ? "approve-all" : "standard"}`);
     console.log(`Runtime: node=${session.runtime.nodeExecutable} codex=${session.runtime.codexExecutable} claude=${session.runtime.claudeExecutable}`);
+    if (session.fullAccessMode) {
+        console.log(renderFullAccessWarning());
+    }
     for (const worktree of session.worktrees){
         console.log(`- ${worktree.agent}: ${worktree.path}`);
     }
@@ -547,6 +566,7 @@ async function commandStatus(cwd, args) {
         goal: session.goal,
         daemonPid: session.daemonPid,
         daemonHeartbeatAt: session.daemonHeartbeatAt,
+        fullAccessMode: session.fullAccessMode,
         daemonHealthy: isSessionLive(session),
         rpcConnected: await pingRpc(paths),
         heartbeatAgeMs,
@@ -604,6 +624,7 @@ async function commandStatus(cwd, args) {
     console.log(`Status: ${payload.status}${payload.daemonHealthy ? " (healthy)" : " (stale or stopped)"}`);
     console.log(`Repo: ${payload.repoRoot}`);
     console.log(`Control: ${payload.socketPath}${payload.rpcConnected ? " (connected)" : " (disconnected)"}`);
+    console.log(`Access: ${payload.fullAccessMode ? "approve-all" : "standard"}`);
     console.log(`Goal: ${payload.goal ?? "-"}`);
     console.log(`Workflow stage: ${payload.workflowStage.label} | ${payload.workflowStage.detail}`);
     if (payload.latestLandReport) {
@@ -1528,6 +1549,18 @@ async function commandHook(args) {
     };
     if (session && agent === "claude" && eventName === "PreToolUse") {
         const descriptor = describeToolUse(payload);
+        if (session.fullAccessMode) {
+            console.log(JSON.stringify({
+                continue: true,
+                suppressOutput: true,
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "allow",
+                    permissionDecisionReason: `Kavi approve-all bypassed approval: ${descriptor.summary}`
+                }
+            }));
+            return;
+        }
         if (CLAUDE_AUTO_ALLOW_TOOLS.has(descriptor.toolName)) {
             await recordEvent(paths, session.id, "approval.auto_allowed", {
                 agent,

package/dist/rpc.js

@@ -124,6 +124,11 @@ export async function rpcRestoreRecommendation(paths, params) {
 export async function rpcResolveApproval(paths, params) {
     await sendRpcRequest(paths, "resolveApproval", params);
 }
+export async function rpcSetFullAccessMode(paths, params) {
+    await sendRpcRequest(paths, "setFullAccessMode", {
+        enabled: params.enabled === true
+    });
+}
 export async function rpcShutdown(paths) {
     await sendRpcRequest(paths, "shutdown");
 }

package/dist/session.js

@@ -15,7 +15,7 @@ function initialAgentStatus(agent, transport) {
         summary: null
     };
 }
-export async function createSessionRecord(paths, config, runtime, sessionId, baseCommit, worktrees, goal, rpcEndpoint) {
+export async function createSessionRecord(paths, config, runtime, sessionId, baseCommit, worktrees, goal, rpcEndpoint, fullAccessMode = false) {
     const timestamp = nowIso();
     const record = {
         id: sessionId,
@@ -26,6 +26,7 @@ export async function createSessionRecord(paths, config, runtime, sessionId, bas
         socketPath: rpcEndpoint,
         status: "starting",
         goal,
+        fullAccessMode,
         daemonPid: null,
         daemonHeartbeatAt: null,
         config,
@@ -50,6 +51,7 @@ export async function loadSessionRecord(paths) {
     if (!record.runtime) {
         record.runtime = await resolveSessionRuntime(paths);
     }
+    record.fullAccessMode = record.fullAccessMode === true;
     record.tasks = Array.isArray(record.tasks) ? record.tasks.map((task)=>({
             ...task,
             routeReason: typeof task.routeReason === "string" ? task.routeReason : null,

package/dist/tui.js

@@ -6,7 +6,7 @@ import { findOwnershipRuleConflicts } from "./ownership.js";
 import { buildOperatorRecommendations, buildRecommendationActionPlan } from "./recommendations.js";
 import { cycleReviewAssignee, reviewNoteMatchesFilters } from "./reviews.js";
 import { extractPromptPathHints, previewRouteDecision, routeTask } from "./router.js";
-import { pingRpc, rpcAddReviewNote, rpcAddReviewReply, rpcDismissRecommendation, rpcEnqueueReviewFollowUp, readSnapshot, rpcEnqueueTask, rpcResolveApproval, rpcRestoreRecommendation, rpcSetReviewNoteStatus, rpcShutdown, rpcTaskArtifact, rpcUpdateReviewNote, rpcWorktreeDiff, subscribeSnapshotRpc } from "./rpc.js";
+import { pingRpc, rpcAddReviewNote, rpcAddReviewReply, rpcDismissRecommendation, rpcEnqueueReviewFollowUp, readSnapshot, rpcEnqueueTask, rpcResolveApproval, rpcSetFullAccessMode, rpcRestoreRecommendation, rpcSetReviewNoteStatus, rpcShutdown, rpcTaskArtifact, rpcUpdateReviewNote, rpcWorktreeDiff, subscribeSnapshotRpc } from "./rpc.js";
 import { buildWorkflowActivity, buildWorkflowResult, buildWorkflowSummary } from "./workflow.js";
 const RESET = "\u001b[0m";
 const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
@@ -32,6 +32,15 @@ export const OPERATOR_TABS = [
     "messages",
     "worktrees"
 ];
+export function nextComposerOwner(current, delta = 1) {
+    const order = [
+        "auto",
+        "codex",
+        "claude"
+    ];
+    const currentIndex = Math.max(0, order.indexOf(current));
+    return order[(currentIndex + delta + order.length) % order.length] ?? current;
+}
 const TASK_DETAIL_SECTIONS = [
     "overview",
     "prompt",
@@ -1461,7 +1470,7 @@ function renderHeader(view, ui, width) {
     const workflowSummary = snapshot ? buildWorkflowSummary(snapshot) : null;
     const repoName = path.basename(session?.repoRoot ?? process.cwd());
     const line1 = fitAnsiLine(`${toneForPanel("Kavi Operator", true)} | session=${session?.id ?? "-"} | repo=${repoName} | rpc=${view.connected ? "connected" : "disconnected"}`, width);
-    const line2 = fitAnsiLine(`Goal: ${session?.goal ?? "-"} | stage=${workflowSummary?.stage.label ?? "-"} | status=${session?.status ?? "-"} | refresh=${shortTime(view.refreshedAt)}`, width);
+    const line2 = fitAnsiLine(`Goal: ${session?.goal ?? "-"} | stage=${workflowSummary?.stage.label ?? "-"} | status=${session?.status ?? "-"} | access=${session?.fullAccessMode ? "approve-all" : "standard"} | refresh=${shortTime(view.refreshedAt)}`, width);
     const line3 = fitAnsiLine(session ? `Tasks P:${countTasks(session.tasks, "pending")} R:${countTasks(session.tasks, "running")} B:${countTasks(session.tasks, "blocked")} C:${countTasks(session.tasks, "completed")} F:${countTasks(session.tasks, "failed")} | approvals=${snapshot?.approvals.filter((approval)=>approval.status === "pending").length ?? 0} | reviews=${countOpenReviewNotes(snapshot)} | claims=${session.pathClaims.filter((claim)=>claim.status === "active").length} | recs=${buildOperatorRecommendations(session, {
         includeDismissed: true
     }).filter((item)=>item.status === "active").length}/${buildOperatorRecommendations(session, {
@@ -1513,7 +1522,7 @@ function renderFooter(snapshot, ui, width) {
         const previewMetadata = preview && preview.metadata && typeof preview.metadata === "object" ? preview.metadata : {};
         const winningRule = previewMetadata.winningRule && typeof previewMetadata.winningRule === "object" ? previewMetadata.winningRule : null;
         const composerHeader = fitAnsiLine(styleLine("Compose Task", "accent", "strong"), width);
-        const composerLine = fitAnsiLine(`Route: ${ui.composer.owner} | 1 auto 2 codex 3 claude | Enter submit | Esc cancel | Ctrl+U clear`, width);
+        const composerLine = fitAnsiLine(`Route: ${ui.composer.owner} | Tab cycle route | Enter submit | Esc cancel | Ctrl+U clear`, width);
         const previewLine = fitAnsiLine(preview ? `Preview: ${preview.owner} via ${preview.strategy} (${preview.confidence.toFixed(2)}) | ${preview.reason}` : "Preview: waiting for prompt", width);
         const diagnosticsLine = fitAnsiLine(preview ? `Hints: ${preview.claimedPaths.join(", ") || "-"} | rule=${typeof winningRule?.pattern === "string" ? winningRule.pattern : "-"}` : "Hints: -", width);
         const promptLine = fitAnsiLine(`> ${ui.composer.prompt}`, width);
@@ -1523,14 +1532,14 @@ function renderFooter(snapshot, ui, width) {
             previewLine,
             diagnosticsLine,
             promptLine,
-            fitAnsiLine(toast ? styleLine(toast.message, toast.level === "error" ? "bad" : "good") : styleLine("Composer accepts free text; tasks are routed or assigned when you press Enter.", "muted"), width)
+            fitAnsiLine(toast ? styleLine(toast.message, toast.level === "error" ? "bad" : "good") : styleLine(snapshot?.session.fullAccessMode ? "Approve-all is enabled. Future Claude and Codex turns will run with full access when you press Enter." : "Composer accepts free text; tasks are routed or assigned when you press Enter.", snapshot?.session.fullAccessMode ? "warn" : "muted"), width)
         ];
     }
     return [
-        fitAnsiLine("Keys: 1-9 tabs | h/l or Tab cycle tabs | j/k move | [ ] task detail | ,/. diff file | { } diff hunk | c compose | r refresh", width),
+        fitAnsiLine("Keys: 1-9 tabs | h/l or Tab cycle tabs | j/k move | [ ] task detail | ,/. diff file | { } diff hunk | c compose | ! toggle approve-all | r refresh", width),
         fitAnsiLine("Actions: Enter apply rec | P force apply rec | z dismiss rec | Z restore rec | y/Y allow approval | n/N deny approval | A/C/Q/M add note | o/O select note | T reply | E edit | R resolve | a cycle assignee | u filter assignee | v filter status | d filter disposition | w won't fix | x accepted risk | F fix task | H handoff | g/G top/bottom | s stop daemon | q quit", width),
         footerSelectionSummary(snapshot, ui, width),
-        fitAnsiLine(toast ? styleLine(toast.message, toast.level === "error" ? "bad" : "good") : styleLine("Operator surface is live over the daemon socket with pushed snapshots.", "muted"), width)
+        fitAnsiLine(toast ? styleLine(toast.message, toast.level === "error" ? "bad" : "good") : styleLine(snapshot?.session.fullAccessMode ? "Approve-all is enabled: Claude and Codex may run commands and edit files without Kavi approval prompts." : "Operator surface is live over the daemon socket with pushed snapshots.", snapshot?.session.fullAccessMode ? "warn" : "muted"), width)
     ];
 }
 function buildLayout(width, height) {
@@ -2101,6 +2110,18 @@ export async function attachTui(paths) {
             }
         });
     };
+    const toggleFullAccessMode = async ()=>{
+        const session = view.snapshot?.session ?? null;
+        if (!session) {
+            throw new Error("No session snapshot is loaded yet.");
+        }
+        const enabled = !session.fullAccessMode;
+        await rpcSetFullAccessMode(paths, {
+            enabled
+        });
+        setToast(ui, "info", enabled ? "Approve-all enabled. Future Claude and Codex turns will run with full access and without Kavi approval prompts." : "Approve-all disabled. Future Claude and Codex turns will return to standard approval and sandbox behavior.");
+        render();
+    };
     const close = ()=>{
         if (closed) {
             return;
@@ -2199,22 +2220,7 @@ export async function attachTui(paths) {
                     return;
                 }
                 if (key.name === "tab" || input === "\t") {
-                    ui.composer.owner = ui.composer.owner === "auto" ? "codex" : ui.composer.owner === "codex" ? "claude" : "auto";
-                    render();
-                    return;
-                }
-                if (input === "1") {
-                    ui.composer.owner = "auto";
-                    render();
-                    return;
-                }
-                if (input === "2") {
-                    ui.composer.owner = "codex";
-                    render();
-                    return;
-                }
-                if (input === "3") {
-                    ui.composer.owner = "claude";
+                    ui.composer.owner = nextComposerOwner(ui.composer.owner, key.shift ? -1 : 1);
                     render();
                     return;
                 }
@@ -2296,6 +2302,12 @@ export async function attachTui(paths) {
             runAction(refresh);
             return;
         }
+        if (input === "!") {
+            runAction(async ()=>{
+                await toggleFullAccessMode();
+            });
+            return;
+        }
         if (input === "c") {
             ui.composer = {
                 owner: "auto",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandipadk7/kavi",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Managed Codex + Claude collaboration TUI",
   "type": "module",
   "preferGlobal": true,