@doingdev/opencode-claude-manager-plugin 0.1.59 → 0.1.60

package/dist/manager/team-orchestrator.d.ts

@@ -2,7 +2,7 @@ import type { ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapt
 import type { ClaudeSessionService } from '../claude/claude-session.service.js';
 import type { TeamStateStore } from '../state/team-state-store.js';
 import type { TranscriptStore } from '../state/transcript-store.js';
-import type { EngineerFailureResult, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TeamRecord, WorkerCapabilities } from '../types/contracts.js';
+import type { ActivePlan, EngineerFailureResult, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TaskSize, TeamRecord, WorkerCapabilities } from '../types/contracts.js';
 interface DispatchEngineerInput {
     teamId: string;
     cwd: string;
@@ -59,6 +59,15 @@ export declare class TeamOrchestrator {
         lead: EngineerName;
         challenger: EngineerName;
     }>;
+    getActivePlan(cwd: string, teamId: string): Promise<ActivePlan | null>;
+    setActivePlan(cwd: string, teamId: string, plan: {
+        summary: string;
+        taskSize: TaskSize;
+        slices: string[];
+        preAuthorized: boolean;
+    }): Promise<ActivePlan>;
+    clearActivePlan(cwd: string, teamId: string): Promise<void>;
+    updateActivePlanSlice(cwd: string, teamId: string, sliceIndex: number, status: 'in_progress' | 'done' | 'skipped'): Promise<void>;
     private buildSessionSystemPrompt;
     private buildEngineerPrompt;
 }

package/dist/manager/team-orchestrator.js

@@ -383,6 +383,81 @@ export class TeamOrchestrator {
         }
         return { lead, challenger };
     }
+    async getActivePlan(cwd, teamId) {
+        const team = await this.getOrCreateTeam(cwd, teamId);
+        return team.activePlan ?? null;
+    }
+    async setActivePlan(cwd, teamId, plan) {
+        await this.getOrCreateTeam(cwd, teamId);
+        const now = new Date().toISOString();
+        const slices = plan.slices.map((description, index) => ({
+            index,
+            description,
+            status: 'pending',
+        }));
+        const activePlan = {
+            id: `plan-${Date.now()}`,
+            summary: plan.summary,
+            taskSize: plan.taskSize,
+            createdAt: now,
+            confirmedAt: now,
+            preAuthorized: plan.preAuthorized,
+            slices,
+            currentSliceIndex: slices.length > 0 ? 0 : null,
+        };
+        await this.teamStore.updateTeam(cwd, teamId, (team) => ({
+            ...team,
+            updatedAt: now,
+            activePlan,
+        }));
+        return activePlan;
+    }
+    async clearActivePlan(cwd, teamId) {
+        await this.getOrCreateTeam(cwd, teamId);
+        const now = new Date().toISOString();
+        await this.teamStore.updateTeam(cwd, teamId, (team) => ({
+            ...team,
+            updatedAt: now,
+            activePlan: undefined,
+        }));
+    }
+    async updateActivePlanSlice(cwd, teamId, sliceIndex, status) {
+        await this.getOrCreateTeam(cwd, teamId);
+        const now = new Date().toISOString();
+        await this.teamStore.updateTeam(cwd, teamId, (team) => {
+            if (!team.activePlan) {
+                throw new Error(`Cannot update slice: team "${teamId}" has no active plan. Call confirm_plan first.`);
+            }
+            const sliceExists = team.activePlan.slices.some((s) => s.index === sliceIndex);
+            if (!sliceExists) {
+                const sliceCount = team.activePlan.slices.length;
+                const rangeMsg = sliceCount === 0 ? 'plan has no slices' : `valid range: 0–${sliceCount - 1}`;
+                throw new Error(`Cannot update slice: slice index ${sliceIndex} does not exist in active plan "${team.activePlan.id}" (${rangeMsg}).`);
+            }
+            const slices = team.activePlan.slices.map((s) => s.index === sliceIndex
+                ? {
+                    ...s,
+                    status,
+                    ...(status === 'done' || status === 'skipped' ? { completedAt: now } : {}),
+                }
+                : s);
+            const isLastSlice = sliceIndex === team.activePlan.slices.length - 1;
+            const nextIndex = status === 'done' || status === 'skipped'
+                ? isLastSlice
+                    ? null
+                    : sliceIndex + 1
+                : team.activePlan.currentSliceIndex;
+            return {
+                ...team,
+                updatedAt: now,
+                activePlan: {
+                    ...team.activePlan,
+                    slices,
+                    currentSliceIndex: nextIndex,
+                },
+            };
+        });
+    }
     buildSessionSystemPrompt(engineer, mode) {
         const specialistPrompt = this.workerCapabilities[engineer]?.sessionPrompt;
         if (specialistPrompt) {
@@ -416,7 +491,8 @@ function buildModeInstruction(mode) {
         case 'implement':
             return [
                 'Implementation mode.',
-                'Make the changes, run the most relevant verification (tests, lint, typecheck), and report what changed and what you verified.',
+                'Before making any edits, state a brief implementation plan: which files you will change, what each change does, and why.',
+                'Then make the changes, run the most relevant verification (tests, lint, typecheck), and report what changed and what you verified.',
                 'Before reporting done, review your own diff for issues that pass tests but break in production.',
             ].join(' ');
         case 'verify':

package/dist/plugin/agents/common.d.ts

@@ -11,9 +11,9 @@ export declare const ENGINEER_AGENT_IDS: {
 };
 /** General named engineers only (Tom/John/Maya/Sara/Alex). BrowserQA is a specialist registered separately. */
 export declare const ENGINEER_AGENT_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
-export declare const CTO_ONLY_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
+export declare const CTO_ONLY_TOOL_IDS: readonly ["team_status", "reset_engineer", "confirm_plan", "advance_slice", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
 export declare const ENGINEER_TOOL_IDS: readonly ["claude"];
-export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "claude"];
+export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "reset_engineer", "confirm_plan", "advance_slice", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "claude"];
 export type ToolPermission = 'allow' | 'ask' | 'deny';
 export type AgentPermission = {
     '*'?: ToolPermission;

package/dist/plugin/agents/common.js

@@ -15,6 +15,8 @@ export const ENGINEER_AGENT_NAMES = PLANNER_ELIGIBLE_ENGINEERS;
 export const CTO_ONLY_TOOL_IDS = [
     'team_status',
     'reset_engineer',
+    'confirm_plan',
+    'advance_slice',
     'list_transcripts',
     'list_history',
     'git_diff',

package/dist/plugin/claude-manager.plugin.js

@@ -206,6 +206,49 @@ export const ClaudeManagerPlugin = async ({ worktree, client }) => {
                     }, null, 2);
                 },
             }),
+            confirm_plan: tool({
+                description: 'Persist plan confirmation and optional slice metadata after the user confirms a plan. For large tasks, provide a slice list to enable per-slice progress tracking. Set preAuthorized to true only when the user has explicitly said to proceed through all slices without further confirmation.',
+                args: {
+                    summary: tool.schema.string().min(1),
+                    taskSize: tool.schema.enum(['trivial', 'simple', 'large']),
+                    slices: tool.schema.string().array().optional(),
+                    preAuthorized: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    const teamId = context.sessionID;
+                    annotateToolRun(context, 'Persisting confirmed plan', {
+                        teamId,
+                        taskSize: args.taskSize,
+                        sliceCount: args.slices?.length ?? 0,
+                    });
+                    const activePlan = await services.orchestrator.setActivePlan(context.worktree, teamId, {
+                        summary: args.summary,
+                        taskSize: args.taskSize,
+                        slices: args.slices ?? [],
+                        preAuthorized: args.preAuthorized ?? false,
+                    });
+                    return JSON.stringify(activePlan, null, 2);
+                },
+            }),
+            advance_slice: tool({
+                description: 'Mark a plan slice as done (or skipped) and advance to the next one. Use this after each slice completes to track large-task progress.',
+                args: {
+                    sliceIndex: tool.schema.number(),
+                    status: tool.schema.enum(['done', 'skipped']).optional(),
+                },
+                async execute(args, context) {
+                    const teamId = context.sessionID;
+                    const status = args.status ?? 'done';
+                    annotateToolRun(context, `Advancing slice ${args.sliceIndex} → ${status}`, {
+                        teamId,
+                        sliceIndex: args.sliceIndex,
+                        status,
+                    });
+                    await services.orchestrator.updateActivePlanSlice(context.worktree, teamId, args.sliceIndex, status);
+                    const team = await services.orchestrator.getOrCreateTeam(context.worktree, teamId);
+                    return JSON.stringify({ activePlan: team.activePlan ?? null }, null, 2);
+                },
+            }),
             reset_engineer: tool({
                 description: 'Reset a stuck or corrupted engineer. Clears the busy flag. Optionally clears the Claude session (starts fresh) and/or wrapper history.',
                 args: {

package/dist/prompts/registry.js

@@ -4,7 +4,7 @@ export const managerPromptRegistry = {
         'Your role is to decompose work, delegate precisely, review diffs for production risks, and verify outcomes.',
         'You do not write code. All edits go through engineers. You multiply output by coordinating parallel work and catching issues others miss.',
         '',
-        '# Operating Loop: Orient → Classify → Plan → Delegate → Review → Verify → Close',
+        '# Operating Loop: Orient → Classify → Plan → Confirm → Delegate → Review → Verify → Close',
         '',
         '## Orient: Understand the request',
         '- Extract what you can from the user message, codebase (read/grep/glob/codesearch), prior engineer results, and `websearch`/`webfetch` when relevant.',
@@ -15,6 +15,7 @@ export const managerPromptRegistry = {
         '',
         '## Classify: Frame the work',
         '- Is this a bug fix, feature, refactor, or something else?',
+        '- Task size: classify as trivial (single-line fix, unambiguous, no side effects), simple (one focused task, clear scope, 1–2 files), or large (multiple steps, cross-cutting changes, requires vertical slicing).',
         '- What could go wrong? Is it reversible or irreversible? Can it fail in prod?',
         '- Does it require careful rollout, data migration, observability, or backwards compatibility handling?',
         '- Are there decisions the user has not explicitly made (architecture, scope, deployment strategy)?',
@@ -24,16 +25,29 @@ export const managerPromptRegistry = {
         "- For medium or large tasks: use `task(subagent_type: 'team-planner', ...)` for dual-engineer exploration and plan synthesis.",
         '  - Team-planner automatically selects two non-overlapping engineers by availability and context; you may optionally specify lead and challenger.',
         '  - Challenger engineer identifies missing decisions, risks, and scope gaps before implementation.',
+        '- For large tasks: break into vertical slices before delegating. Each slice must deliver end-to-end, user-testable value independently (e.g., "user can register and receive a confirmation email", "user can view billing history"). Horizontal layers (e.g., "just types", "just tests") are not vertical slices. Document slices when calling `confirm_plan`.',
         '- Break work into independent pieces that can run in parallel. Two engineers exploring then synthesizing beats one engineer doing everything sequentially.',
         '- Before delegating, state your success criteria, not just the task. What done looks like. How you will verify it.',
         '',
+        '## Confirm: Get user buy-in before implementing',
+        '- After planning but before dispatching any engineer in implement mode, present the plan to the user with the `question` tool.',
+        '- State what will be built or changed, which files or systems are affected, what success looks like, and any risks or open decisions.',
+        '- If team-planner synthesis surfaced a recommendedQuestion, include it here as part of the confirmation question.',
+        '- Do not proceed to implementation until the user confirms the plan.',
+        '- After the user confirms, call `confirm_plan` with a summary, taskSize, and (for large tasks) the slice list. Set preAuthorized: true only if the user explicitly says to proceed through all slices without further confirmation.',
+        '- For large tasks not preAuthorized: confirm each slice with the user before dispatching it.',
+        '- Skip `question` only when: the user has explicitly said "proceed" or "just do it", the change is a trivial fix with no ambiguity, or the task is purely exploratory (no edits).',
+        '- If the user refines or rejects the plan, revise it and re-confirm before implementing.',
+        '',
         '## Delegate: Send precise assignments',
         "- For single-engineer work: use `task(subagent_type: 'tom'|'john'|'maya'|'sara'|'alex', ...)` and structure the prompt with goal, acceptance criteria, relevant files, constraints, and verification.",
         "- For dual-engineer planning: use `task(subagent_type: 'team-planner', ...)` which will lead + challenger synthesis.",
         "- For browser/UI verification: use `task(subagent_type: 'browser-qa', ...)` with a clear verification goal. BrowserQA uses the Playwright skill to verify in a real browser and can run safe bash when needed.",
         '- Each assignment includes: goal, acceptance criteria, relevant context, constraints, and verification method.',
+        '- For large tasks: after each slice completes, call `advance_slice` to record progress, then confirm the next slice with the user before dispatching (unless preAuthorized).',
         '- Reuse the same engineer when follow-up work builds on their prior context.',
         '- Only one implementing engineer modifies the worktree at a time. Parallelize exploration, research, and browser verification freely.',
+        '- Context warnings (moderate/high/critical) are informational only. Do NOT reset an engineer session in response to a context warning. Sessions auto-reset only on an actual contextExhausted error.',
         '',
         '## Review: Inspect diffs for production safety',
         '- After an engineer reports implementation done, review the diff with `git_diff` before declaring it complete.',
@@ -66,6 +80,7 @@ export const managerPromptRegistry = {
         '- Questions: Use the `question` tool when a decision will materially affect scope, architecture, or how you verify the outcome. Name the decision, offer 2–3 concrete options, state your recommendation, and say what breaks if the user picks differently. One high-leverage question at a time.',
         '- Reframing: Before planning, ask what the user is actually trying to achieve, not just what they asked for. If the request sounds like a feature, ask what job-to-be-done it serves.',
         '- Engineer selection: When assigning to a single engineer, prefer lower context pressure and less-recently-used engineers. Reuse if follow-up work builds on prior context.',
+        '- Context warnings: At moderate/high/critical context levels the system surfaces a warning. These are advisory — do not force session reset. Reserve reset for actual contextExhausted errors only.',
         '- Failure handling:',
         "  - contextExhausted: The engineer's session ran out of tokens. The system automatically resets and retries once with the same task on a fresh session.",
         '  - sdkError or toolDenied: The underlying SDK failed or a tool call was denied. Investigate the error, adjust constraints, and retry.',
@@ -92,6 +107,7 @@ export const managerPromptRegistry = {
         '',
         'Your wrapper context from prior turns is reloaded automatically. Use it to avoid repeating work or re-explaining context that Claude Code already knows.',
         "Return the tool result directly. Add your own commentary only when something was unexpected or needs the CTO's attention.",
+        'If you discover during implementation that the agreed approach is not viable (unexpected constraints, wrong files, missing context), stop immediately and surface the deviation to the CTO before proceeding with a different approach. Do not silently implement something different from what was confirmed.',
     ].join('\n'),
     engineerSessionPrompt: [
         'You are an expert software engineer working inside Claude Code.',
@@ -149,6 +165,7 @@ export const managerPromptRegistry = {
         '- If lead and challenger engineer names are both specified, use them.',
         '- If either name is missing, `plan_with_team` will auto-select two non-overlapping engineers based on availability and context.',
         'Do not attempt any planning or analysis yourself. Delegate entirely to `plan_with_team`.',
+        'After `plan_with_team` returns, pass the full result back to the CTO unchanged. Do not modify, summarize, or act on the synthesis; the CTO will present it to the user for confirmation.',
     ].join('\n'),
     browserQaAgentPrompt: [
         "You are the browser QA specialist on the CTO's team.",
@@ -165,6 +182,7 @@ export const managerPromptRegistry = {
         '- Never simulate or fabricate test results.',
         '- If the Playwright tool is not available, the result will start with PLAYWRIGHT_UNAVAILABLE:.',
         '- Your persistent Claude Code session remembers prior verification runs.',
+        '- If the verification scope changes unexpectedly (feature absent, URL wrong, task cannot be completed as specified), stop and report the scope mismatch rather than silently verifying something else.',
     ].join('\n'),
     browserQaSessionPrompt: [
         'You are a browser QA specialist. Your job is to verify web features and user flows using the Playwright skill/command.',
@@ -185,8 +203,8 @@ export const managerPromptRegistry = {
         'Allowed tools: Playwright skill/command, safe bash, read-only tools (Read, Grep, Glob). No file editing or code modifications.',
     ].join('\n'),
     contextWarnings: {
-        moderate: 'Engineer context is getting full ({percent}% estimated). Reuse is still fine, but keep the next prompt focused.',
-        high: 'Engineer context is heavy ({percent}% estimated, {turns} turns, ${cost}). Prefer a narrowly scoped follow-up or internal compaction.',
-        critical: 'Engineer context is near capacity ({percent}% estimated). Avoid piling unrelated work into this engineer session.',
+        moderate: 'Engineer context is at {percent}% estimated. Session is healthy; keep the next task focused.',
+        high: 'Engineer context is at {percent}% estimated ({turns} turns, ${cost}). Session continues — prefer a narrowly scoped follow-up.',
+        critical: 'Engineer context is near capacity ({percent}% estimated). Warn only — do not force a reset; avoid large new tasks in this session.',
     },
 };

package/dist/src/manager/team-orchestrator.d.ts

@@ -2,7 +2,7 @@ import type { ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapt
 import type { ClaudeSessionService } from '../claude/claude-session.service.js';
 import type { TeamStateStore } from '../state/team-state-store.js';
 import type { TranscriptStore } from '../state/transcript-store.js';
-import type { EngineerFailureResult, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TeamRecord, WorkerCapabilities } from '../types/contracts.js';
+import type { ActivePlan, EngineerFailureResult, EngineerName, EngineerTaskResult, EngineerWorkMode, SynthesizedPlanResult, TaskSize, TeamRecord, WorkerCapabilities } from '../types/contracts.js';
 interface DispatchEngineerInput {
     teamId: string;
     cwd: string;
@@ -59,6 +59,15 @@ export declare class TeamOrchestrator {
         lead: EngineerName;
         challenger: EngineerName;
     }>;
+    getActivePlan(cwd: string, teamId: string): Promise<ActivePlan | null>;
+    setActivePlan(cwd: string, teamId: string, plan: {
+        summary: string;
+        taskSize: TaskSize;
+        slices: string[];
+        preAuthorized: boolean;
+    }): Promise<ActivePlan>;
+    clearActivePlan(cwd: string, teamId: string): Promise<void>;
+    updateActivePlanSlice(cwd: string, teamId: string, sliceIndex: number, status: 'in_progress' | 'done' | 'skipped'): Promise<void>;
     private buildSessionSystemPrompt;
     private buildEngineerPrompt;
 }

package/dist/src/manager/team-orchestrator.js

@@ -383,6 +383,81 @@ export class TeamOrchestrator {
         }
         return { lead, challenger };
     }
+    async getActivePlan(cwd, teamId) {
+        const team = await this.getOrCreateTeam(cwd, teamId);
+        return team.activePlan ?? null;
+    }
+    async setActivePlan(cwd, teamId, plan) {
+        await this.getOrCreateTeam(cwd, teamId);
+        const now = new Date().toISOString();
+        const slices = plan.slices.map((description, index) => ({
+            index,
+            description,
+            status: 'pending',
+        }));
+        const activePlan = {
+            id: `plan-${Date.now()}`,
+            summary: plan.summary,
+            taskSize: plan.taskSize,
+            createdAt: now,
+            confirmedAt: now,
+            preAuthorized: plan.preAuthorized,
+            slices,
+            currentSliceIndex: slices.length > 0 ? 0 : null,
+        };
+        await this.teamStore.updateTeam(cwd, teamId, (team) => ({
+            ...team,
+            updatedAt: now,
+            activePlan,
+        }));
+        return activePlan;
+    }
+    async clearActivePlan(cwd, teamId) {
+        await this.getOrCreateTeam(cwd, teamId);
+        const now = new Date().toISOString();
+        await this.teamStore.updateTeam(cwd, teamId, (team) => ({
+            ...team,
+            updatedAt: now,
+            activePlan: undefined,
+        }));
+    }
+    async updateActivePlanSlice(cwd, teamId, sliceIndex, status) {
+        await this.getOrCreateTeam(cwd, teamId);
+        const now = new Date().toISOString();
+        await this.teamStore.updateTeam(cwd, teamId, (team) => {
+            if (!team.activePlan) {
+                throw new Error(`Cannot update slice: team "${teamId}" has no active plan. Call confirm_plan first.`);
+            }
+            const sliceExists = team.activePlan.slices.some((s) => s.index === sliceIndex);
+            if (!sliceExists) {
+                const sliceCount = team.activePlan.slices.length;
+                const rangeMsg = sliceCount === 0 ? 'plan has no slices' : `valid range: 0–${sliceCount - 1}`;
+                throw new Error(`Cannot update slice: slice index ${sliceIndex} does not exist in active plan "${team.activePlan.id}" (${rangeMsg}).`);
+            }
+            const slices = team.activePlan.slices.map((s) => s.index === sliceIndex
+                ? {
+                    ...s,
+                    status,
+                    ...(status === 'done' || status === 'skipped' ? { completedAt: now } : {}),
+                }
+                : s);
+            const isLastSlice = sliceIndex === team.activePlan.slices.length - 1;
+            const nextIndex = status === 'done' || status === 'skipped'
+                ? isLastSlice
+                    ? null
+                    : sliceIndex + 1
+                : team.activePlan.currentSliceIndex;
+            return {
+                ...team,
+                updatedAt: now,
+                activePlan: {
+                    ...team.activePlan,
+                    slices,
+                    currentSliceIndex: nextIndex,
+                },
+            };
+        });
+    }
     buildSessionSystemPrompt(engineer, mode) {
         const specialistPrompt = this.workerCapabilities[engineer]?.sessionPrompt;
         if (specialistPrompt) {
@@ -416,7 +491,8 @@ function buildModeInstruction(mode) {
         case 'implement':
             return [
                 'Implementation mode.',
-                'Make the changes, run the most relevant verification (tests, lint, typecheck), and report what changed and what you verified.',
+                'Before making any edits, state a brief implementation plan: which files you will change, what each change does, and why.',
+                'Then make the changes, run the most relevant verification (tests, lint, typecheck), and report what changed and what you verified.',
                 'Before reporting done, review your own diff for issues that pass tests but break in production.',
             ].join(' ');
         case 'verify':

package/dist/src/plugin/agents/common.d.ts

@@ -11,9 +11,9 @@ export declare const ENGINEER_AGENT_IDS: {
 };
 /** General named engineers only (Tom/John/Maya/Sara/Alex). BrowserQA is a specialist registered separately. */
 export declare const ENGINEER_AGENT_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
-export declare const CTO_ONLY_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
+export declare const CTO_ONLY_TOOL_IDS: readonly ["team_status", "reset_engineer", "confirm_plan", "advance_slice", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
 export declare const ENGINEER_TOOL_IDS: readonly ["claude"];
-export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "claude"];
+export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "reset_engineer", "confirm_plan", "advance_slice", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "claude"];
 export type ToolPermission = 'allow' | 'ask' | 'deny';
 export type AgentPermission = {
     '*'?: ToolPermission;

package/dist/src/plugin/agents/common.js

@@ -15,6 +15,8 @@ export const ENGINEER_AGENT_NAMES = PLANNER_ELIGIBLE_ENGINEERS;
 export const CTO_ONLY_TOOL_IDS = [
     'team_status',
     'reset_engineer',
+    'confirm_plan',
+    'advance_slice',
     'list_transcripts',
     'list_history',
     'git_diff',

package/dist/src/plugin/claude-manager.plugin.js

@@ -206,6 +206,49 @@ export const ClaudeManagerPlugin = async ({ worktree, client }) => {
                     }, null, 2);
                 },
             }),
+            confirm_plan: tool({
+                description: 'Persist plan confirmation and optional slice metadata after the user confirms a plan. For large tasks, provide a slice list to enable per-slice progress tracking. Set preAuthorized to true only when the user has explicitly said to proceed through all slices without further confirmation.',
+                args: {
+                    summary: tool.schema.string().min(1),
+                    taskSize: tool.schema.enum(['trivial', 'simple', 'large']),
+                    slices: tool.schema.string().array().optional(),
+                    preAuthorized: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    const teamId = context.sessionID;
+                    annotateToolRun(context, 'Persisting confirmed plan', {
+                        teamId,
+                        taskSize: args.taskSize,
+                        sliceCount: args.slices?.length ?? 0,
+                    });
+                    const activePlan = await services.orchestrator.setActivePlan(context.worktree, teamId, {
+                        summary: args.summary,
+                        taskSize: args.taskSize,
+                        slices: args.slices ?? [],
+                        preAuthorized: args.preAuthorized ?? false,
+                    });
+                    return JSON.stringify(activePlan, null, 2);
+                },
+            }),
+            advance_slice: tool({
+                description: 'Mark a plan slice as done (or skipped) and advance to the next one. Use this after each slice completes to track large-task progress.',
+                args: {
+                    sliceIndex: tool.schema.number(),
+                    status: tool.schema.enum(['done', 'skipped']).optional(),
+                },
+                async execute(args, context) {
+                    const teamId = context.sessionID;
+                    const status = args.status ?? 'done';
+                    annotateToolRun(context, `Advancing slice ${args.sliceIndex} → ${status}`, {
+                        teamId,
+                        sliceIndex: args.sliceIndex,
+                        status,
+                    });
+                    await services.orchestrator.updateActivePlanSlice(context.worktree, teamId, args.sliceIndex, status);
+                    const team = await services.orchestrator.getOrCreateTeam(context.worktree, teamId);
+                    return JSON.stringify({ activePlan: team.activePlan ?? null }, null, 2);
+                },
+            }),
             reset_engineer: tool({
                 description: 'Reset a stuck or corrupted engineer. Clears the busy flag. Optionally clears the Claude session (starts fresh) and/or wrapper history.',
                 args: {

package/dist/src/prompts/registry.js

@@ -4,7 +4,7 @@ export const managerPromptRegistry = {
         'Your role is to decompose work, delegate precisely, review diffs for production risks, and verify outcomes.',
         'You do not write code. All edits go through engineers. You multiply output by coordinating parallel work and catching issues others miss.',
         '',
-        '# Operating Loop: Orient → Classify → Plan → Delegate → Review → Verify → Close',
+        '# Operating Loop: Orient → Classify → Plan → Confirm → Delegate → Review → Verify → Close',
         '',
         '## Orient: Understand the request',
         '- Extract what you can from the user message, codebase (read/grep/glob/codesearch), prior engineer results, and `websearch`/`webfetch` when relevant.',
@@ -15,6 +15,7 @@ export const managerPromptRegistry = {
         '',
         '## Classify: Frame the work',
         '- Is this a bug fix, feature, refactor, or something else?',
+        '- Task size: classify as trivial (single-line fix, unambiguous, no side effects), simple (one focused task, clear scope, 1–2 files), or large (multiple steps, cross-cutting changes, requires vertical slicing).',
         '- What could go wrong? Is it reversible or irreversible? Can it fail in prod?',
         '- Does it require careful rollout, data migration, observability, or backwards compatibility handling?',
         '- Are there decisions the user has not explicitly made (architecture, scope, deployment strategy)?',
@@ -24,16 +25,29 @@ export const managerPromptRegistry = {
         "- For medium or large tasks: use `task(subagent_type: 'team-planner', ...)` for dual-engineer exploration and plan synthesis.",
         '  - Team-planner automatically selects two non-overlapping engineers by availability and context; you may optionally specify lead and challenger.',
         '  - Challenger engineer identifies missing decisions, risks, and scope gaps before implementation.',
+        '- For large tasks: break into vertical slices before delegating. Each slice must deliver end-to-end, user-testable value independently (e.g., "user can register and receive a confirmation email", "user can view billing history"). Horizontal layers (e.g., "just types", "just tests") are not vertical slices. Document slices when calling `confirm_plan`.',
         '- Break work into independent pieces that can run in parallel. Two engineers exploring then synthesizing beats one engineer doing everything sequentially.',
         '- Before delegating, state your success criteria, not just the task. What done looks like. How you will verify it.',
         '',
+        '## Confirm: Get user buy-in before implementing',
+        '- After planning but before dispatching any engineer in implement mode, present the plan to the user with the `question` tool.',
+        '- State what will be built or changed, which files or systems are affected, what success looks like, and any risks or open decisions.',
+        '- If team-planner synthesis surfaced a recommendedQuestion, include it here as part of the confirmation question.',
+        '- Do not proceed to implementation until the user confirms the plan.',
+        '- After the user confirms, call `confirm_plan` with a summary, taskSize, and (for large tasks) the slice list. Set preAuthorized: true only if the user explicitly says to proceed through all slices without further confirmation.',
+        '- For large tasks not preAuthorized: confirm each slice with the user before dispatching it.',
+        '- Skip `question` only when: the user has explicitly said "proceed" or "just do it", the change is a trivial fix with no ambiguity, or the task is purely exploratory (no edits).',
+        '- If the user refines or rejects the plan, revise it and re-confirm before implementing.',
+        '',
         '## Delegate: Send precise assignments',
         "- For single-engineer work: use `task(subagent_type: 'tom'|'john'|'maya'|'sara'|'alex', ...)` and structure the prompt with goal, acceptance criteria, relevant files, constraints, and verification.",
         "- For dual-engineer planning: use `task(subagent_type: 'team-planner', ...)` which will lead + challenger synthesis.",
         "- For browser/UI verification: use `task(subagent_type: 'browser-qa', ...)` with a clear verification goal. BrowserQA uses the Playwright skill to verify in a real browser and can run safe bash when needed.",
         '- Each assignment includes: goal, acceptance criteria, relevant context, constraints, and verification method.',
+        '- For large tasks: after each slice completes, call `advance_slice` to record progress, then confirm the next slice with the user before dispatching (unless preAuthorized).',
         '- Reuse the same engineer when follow-up work builds on their prior context.',
         '- Only one implementing engineer modifies the worktree at a time. Parallelize exploration, research, and browser verification freely.',
+        '- Context warnings (moderate/high/critical) are informational only. Do NOT reset an engineer session in response to a context warning. Sessions auto-reset only on an actual contextExhausted error.',
         '',
         '## Review: Inspect diffs for production safety',
         '- After an engineer reports implementation done, review the diff with `git_diff` before declaring it complete.',
@@ -66,6 +80,7 @@ export const managerPromptRegistry = {
         '- Questions: Use the `question` tool when a decision will materially affect scope, architecture, or how you verify the outcome. Name the decision, offer 2–3 concrete options, state your recommendation, and say what breaks if the user picks differently. One high-leverage question at a time.',
         '- Reframing: Before planning, ask what the user is actually trying to achieve, not just what they asked for. If the request sounds like a feature, ask what job-to-be-done it serves.',
         '- Engineer selection: When assigning to a single engineer, prefer lower context pressure and less-recently-used engineers. Reuse if follow-up work builds on prior context.',
+        '- Context warnings: At moderate/high/critical context levels the system surfaces a warning. These are advisory — do not force session reset. Reserve reset for actual contextExhausted errors only.',
         '- Failure handling:',
         "  - contextExhausted: The engineer's session ran out of tokens. The system automatically resets and retries once with the same task on a fresh session.",
         '  - sdkError or toolDenied: The underlying SDK failed or a tool call was denied. Investigate the error, adjust constraints, and retry.',
@@ -92,6 +107,7 @@ export const managerPromptRegistry = {
         '',
         'Your wrapper context from prior turns is reloaded automatically. Use it to avoid repeating work or re-explaining context that Claude Code already knows.',
         "Return the tool result directly. Add your own commentary only when something was unexpected or needs the CTO's attention.",
+        'If you discover during implementation that the agreed approach is not viable (unexpected constraints, wrong files, missing context), stop immediately and surface the deviation to the CTO before proceeding with a different approach. Do not silently implement something different from what was confirmed.',
     ].join('\n'),
     engineerSessionPrompt: [
         'You are an expert software engineer working inside Claude Code.',
@@ -149,6 +165,7 @@ export const managerPromptRegistry = {
         '- If lead and challenger engineer names are both specified, use them.',
         '- If either name is missing, `plan_with_team` will auto-select two non-overlapping engineers based on availability and context.',
         'Do not attempt any planning or analysis yourself. Delegate entirely to `plan_with_team`.',
+        'After `plan_with_team` returns, pass the full result back to the CTO unchanged. Do not modify, summarize, or act on the synthesis; the CTO will present it to the user for confirmation.',
     ].join('\n'),
     browserQaAgentPrompt: [
         "You are the browser QA specialist on the CTO's team.",
@@ -165,6 +182,7 @@ export const managerPromptRegistry = {
         '- Never simulate or fabricate test results.',
         '- If the Playwright tool is not available, the result will start with PLAYWRIGHT_UNAVAILABLE:.',
         '- Your persistent Claude Code session remembers prior verification runs.',
+        '- If the verification scope changes unexpectedly (feature absent, URL wrong, task cannot be completed as specified), stop and report the scope mismatch rather than silently verifying something else.',
     ].join('\n'),
     browserQaSessionPrompt: [
         'You are a browser QA specialist. Your job is to verify web features and user flows using the Playwright skill/command.',
@@ -185,8 +203,8 @@ export const managerPromptRegistry = {
         'Allowed tools: Playwright skill/command, safe bash, read-only tools (Read, Grep, Glob). No file editing or code modifications.',
     ].join('\n'),
     contextWarnings: {
-        moderate: 'Engineer context is getting full ({percent}% estimated). Reuse is still fine, but keep the next prompt focused.',
-        high: 'Engineer context is heavy ({percent}% estimated, {turns} turns, ${cost}). Prefer a narrowly scoped follow-up or internal compaction.',
-        critical: 'Engineer context is near capacity ({percent}% estimated). Avoid piling unrelated work into this engineer session.',
+        moderate: 'Engineer context is at {percent}% estimated. Session is healthy; keep the next task focused.',
+        high: 'Engineer context is at {percent}% estimated ({turns} turns, ${cost}). Session continues — prefer a narrowly scoped follow-up.',
+        critical: 'Engineer context is near capacity ({percent}% estimated). Warn only — do not force a reset; avoid large new tasks in this session.',
     },
 };

package/dist/src/types/contracts.d.ts

@@ -116,6 +116,24 @@ export interface SessionContextSnapshot {
     warningLevel: ContextWarningLevel;
     compactionCount: number;
 }
+export type TaskSize = 'trivial' | 'simple' | 'large';
+export interface PlanSlice {
+    index: number;
+    description: string;
+    status: 'pending' | 'in_progress' | 'done' | 'skipped';
+    completedAt?: string;
+}
+export interface ActivePlan {
+    id: string;
+    summary: string;
+    taskSize: TaskSize;
+    createdAt: string;
+    confirmedAt: string | null;
+    preAuthorized: boolean;
+    slices: PlanSlice[];
+    /** Null when the plan has no slices (trivial/simple tasks). */
+    currentSliceIndex: number | null;
+}
 export interface TeamEngineerRecord {
     name: EngineerName;
     wrapperSessionId: string | null;
@@ -142,6 +160,7 @@ export interface TeamRecord {
     createdAt: string;
     updatedAt: string;
     engineers: TeamEngineerRecord[];
+    activePlan?: ActivePlan;
 }
 export interface EngineerTaskResult {
     teamId: string;

package/dist/test/claude-manager.plugin.test.js

@@ -1,6 +1,10 @@
-import { describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 import { ClaudeManagerPlugin } from '../src/plugin/claude-manager.plugin.js';
 import { AGENT_CTO, AGENT_TEAM_PLANNER, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from '../src/plugin/agent-hierarchy.js';
+import { clearPluginServices } from '../src/plugin/service-factory.js';
 describe('ClaudeManagerPlugin', () => {
     it('configures CTO with orchestration tools and question access', async () => {
         const plugin = await ClaudeManagerPlugin({
@@ -27,6 +31,8 @@ describe('ClaudeManagerPlugin', () => {
             question: 'allow',
             team_status: 'allow',
             reset_engineer: 'allow',
+            confirm_plan: 'allow',
+            advance_slice: 'allow',
             git_diff: 'allow',
             git_commit: 'allow',
             git_reset: 'allow',
@@ -121,6 +127,8 @@ describe('ClaudeManagerPlugin', () => {
         expect(tools['claude']).toBeDefined();
         expect(tools['team_status']).toBeDefined();
         expect(tools['plan_with_team']).toBeDefined();
+        expect(tools['confirm_plan']).toBeDefined();
+        expect(tools['advance_slice']).toBeDefined();
         expect(tools['reset_engineer']).toBeDefined();
         expect(tools['assign_engineer']).toBeUndefined();
     });
@@ -144,6 +152,63 @@ describe('ClaudeManagerPlugin', () => {
         expect(modelSchema.safeParse(undefined).success).toBe(true);
         expect(modelSchema.safeParse('claude-haiku-4-5').success).toBe(false);
     });
+    it('confirm_plan tool validates taskSize enum and requires summary', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        const confirmPlan = tools['confirm_plan'];
+        expect(confirmPlan).toBeDefined();
+        const summarySchema = confirmPlan.args.summary;
+        const taskSizeSchema = confirmPlan.args.taskSize;
+        const slicesSchema = confirmPlan.args.slices;
+        const preAuthorizedSchema = confirmPlan.args.preAuthorized;
+        expect(summarySchema.safeParse('Billing refactor').success).toBe(true);
+        expect(summarySchema.safeParse('').success).toBe(false);
+        expect(taskSizeSchema.safeParse('trivial').success).toBe(true);
+        expect(taskSizeSchema.safeParse('simple').success).toBe(true);
+        expect(taskSizeSchema.safeParse('large').success).toBe(true);
+        expect(taskSizeSchema.safeParse('medium').success).toBe(false);
+        expect(taskSizeSchema.safeParse('huge').success).toBe(false);
+        // slices is optional — absent and array both valid
+        expect(slicesSchema.safeParse(undefined).success).toBe(true);
+        expect(slicesSchema.safeParse(['slice A', 'slice B']).success).toBe(true);
+        // preAuthorized is optional boolean
+        expect(preAuthorizedSchema.safeParse(true).success).toBe(true);
+        expect(preAuthorizedSchema.safeParse(false).success).toBe(true);
+        expect(preAuthorizedSchema.safeParse(undefined).success).toBe(true);
+    });
+    it('advance_slice tool validates sliceIndex and optional status enum', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const tools = plugin.tool;
+        const advanceSlice = tools['advance_slice'];
+        expect(advanceSlice).toBeDefined();
+        const sliceIndexSchema = advanceSlice.args.sliceIndex;
+        const statusSchema = advanceSlice.args.status;
+        expect(sliceIndexSchema.safeParse(0).success).toBe(true);
+        expect(sliceIndexSchema.safeParse(2).success).toBe(true);
+        expect(sliceIndexSchema.safeParse('0').success).toBe(false);
+        expect(statusSchema.safeParse('done').success).toBe(true);
+        expect(statusSchema.safeParse('skipped').success).toBe(true);
+        expect(statusSchema.safeParse(undefined).success).toBe(true);
+        expect(statusSchema.safeParse('in_progress').success).toBe(false);
+    });
+    it('confirm_plan and advance_slice are denied for engineers', async () => {
+        const plugin = await ClaudeManagerPlugin({
+            worktree: '/tmp/project',
+        });
+        const config = {};
+        await plugin.config?.(config);
+        const agents = (config.agent ?? {});
+        for (const engineer of ENGINEER_AGENT_NAMES) {
+            const agentId = ENGINEER_AGENT_IDS[engineer];
+            const agent = agents[agentId];
+            expect(agent.permission['confirm_plan']).toBe('deny');
+            expect(agent.permission['advance_slice']).toBe('deny');
+        }
+    });
     it('exposes hooks for CTO team tracking and wrapper memory injection', async () => {
         const plugin = await ClaudeManagerPlugin({
             worktree: '/tmp/project',
@@ -270,3 +335,109 @@ describe('Agent ID normalization and lookup helpers', () => {
         expect(agents['browser-qa']).toBeDefined();
     });
 });
+describe('confirm_plan and advance_slice tool execution', () => {
+    let tempRoot;
+    afterEach(async () => {
+        clearPluginServices();
+        if (tempRoot) {
+            await rm(tempRoot, { recursive: true, force: true });
+        }
+    });
+    it('confirm_plan persists an active plan and returns it as JSON', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const tools = plugin.tool;
+        const context = {
+            sessionID: 'cto-sess-confirm',
+            worktree: tempRoot,
+            agent: AGENT_CTO,
+            metadata: vi.fn(),
+        };
+        const result = await tools['confirm_plan'].execute({
+            summary: 'Add billing history',
+            taskSize: 'large',
+            slices: ['user can view invoices', 'user can update payment method'],
+            preAuthorized: false,
+        }, context);
+        const activePlan = JSON.parse(result);
+        expect(activePlan['summary']).toBe('Add billing history');
+        expect(activePlan['taskSize']).toBe('large');
+        expect(activePlan['currentSliceIndex']).toBe(0);
+        expect(activePlan['preAuthorized']).toBe(false);
+        expect(activePlan['slices'].length).toBe(2);
+    });
+    it('advance_slice marks a slice done and returns updated plan state', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const tools = plugin.tool;
+        const context = {
+            sessionID: 'cto-sess-advance',
+            worktree: tempRoot,
+            agent: AGENT_CTO,
+            metadata: vi.fn(),
+        };
+        // Set up plan with two slices
+        await tools['confirm_plan'].execute({
+            summary: 'Two-slice task',
+            taskSize: 'large',
+            slices: ['user can log in', 'user can log out'],
+            preAuthorized: false,
+        }, context);
+        // Advance non-final slice 0
+        const result = await tools['advance_slice'].execute({ sliceIndex: 0, status: 'done' }, context);
+        const payload = JSON.parse(result);
+        const slices = payload.activePlan['slices'];
+        expect(slices[0]['status']).toBe('done');
+        expect(payload.activePlan['currentSliceIndex']).toBe(1);
+    });
+    it('advance_slice sets currentSliceIndex to null when completing the final slice', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const tools = plugin.tool;
+        const context = {
+            sessionID: 'cto-sess-final',
+            worktree: tempRoot,
+            agent: AGENT_CTO,
+            metadata: vi.fn(),
+        };
+        await tools['confirm_plan'].execute({
+            summary: 'Single-slice task',
+            taskSize: 'large',
+            slices: ['ship the feature'],
+            preAuthorized: true,
+        }, context);
+        const result = await tools['advance_slice'].execute({ sliceIndex: 0, status: 'done' }, context);
+        const payload = JSON.parse(result);
+        expect(payload.activePlan['currentSliceIndex']).toBeNull();
+    });
+    it('advance_slice throws when there is no active plan', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const tools = plugin.tool;
+        const context = {
+            sessionID: 'cto-sess-no-plan',
+            worktree: tempRoot,
+            agent: AGENT_CTO,
+            metadata: vi.fn(),
+        };
+        await expect(tools['advance_slice'].execute({ sliceIndex: 0 }, context)).rejects.toThrow('has no active plan');
+    });
+    it('advance_slice throws when the slice index is invalid', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'plugin-exec-'));
+        const plugin = await ClaudeManagerPlugin({ worktree: tempRoot });
+        const tools = plugin.tool;
+        const context = {
+            sessionID: 'cto-sess-bad-idx',
+            worktree: tempRoot,
+            agent: AGENT_CTO,
+            metadata: vi.fn(),
+        };
+        await tools['confirm_plan'].execute({
+            summary: 'Two-slice task',
+            taskSize: 'large',
+            slices: ['slice A', 'slice B'],
+            preAuthorized: false,
+        }, context);
+        await expect(tools['advance_slice'].execute({ sliceIndex: 99 }, context)).rejects.toThrow('slice index 99 does not exist');
+    });
+});

package/dist/test/prompt-registry.test.js

@@ -45,6 +45,26 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.teamPlannerPrompt).toContain('auto-select');
         expect(managerPromptRegistry.teamPlannerPrompt).toContain('engineer');
     });
+    it('ctoSystemPrompt includes Confirm step in operating loop before Delegate', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Orient → Classify → Plan → Confirm → Delegate');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Confirm: Get user buy-in before implementing');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('recommendedQuestion');
+        // Confirm section must appear before Delegate section in the text
+        const confirmIdx = managerPromptRegistry.ctoSystemPrompt.indexOf('## Confirm:');
+        const delegateIdx = managerPromptRegistry.ctoSystemPrompt.indexOf('## Delegate:');
+        expect(confirmIdx).toBeGreaterThan(-1);
+        expect(confirmIdx).toBeLessThan(delegateIdx);
+    });
+    it('engineerAgentPrompt instructs engineers to surface plan deviations', () => {
+        expect(managerPromptRegistry.engineerAgentPrompt).toContain('deviation');
+        expect(managerPromptRegistry.engineerAgentPrompt).toContain('surface');
+    });
+    it('browserQaAgentPrompt instructs browser-qa to report scope mismatches', () => {
+        expect(managerPromptRegistry.browserQaAgentPrompt).toContain('scope mismatch');
+    });
+    it('teamPlannerPrompt instructs planner to pass synthesis back unchanged', () => {
+        expect(managerPromptRegistry.teamPlannerPrompt).toContain('unchanged');
+    });
     it('ctoSystemPrompt delegates single work to named engineers via task() and dual work to team-planner', () => {
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('task(subagent_type:');
         expect(managerPromptRegistry.ctoSystemPrompt).toContain('single-engineer');
@@ -66,4 +86,36 @@ describe('managerPromptRegistry', () => {
         expect(managerPromptRegistry.browserQaSessionPrompt).not.toContain('implement');
         expect(managerPromptRegistry.browserQaSessionPrompt).not.toContain('write code');
     });
+    it('ctoSystemPrompt encodes task size classification (trivial/simple/large)', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('trivial');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('simple');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('large');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Task size');
+    });
+    it('ctoSystemPrompt mentions confirm_plan and advance_slice for large task lifecycle', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('confirm_plan');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('advance_slice');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('preAuthorized');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('vertical slice');
+    });
+    it('ctoSystemPrompt encodes warn-only context policy', () => {
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Context warnings');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('advisory');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('contextExhausted');
+    });
+    it('contextWarnings reflect warn-only policy for critical level', () => {
+        expect(managerPromptRegistry.contextWarnings.critical).toContain('near capacity');
+        expect(managerPromptRegistry.contextWarnings.critical).toContain('Warn only');
+    });
+    it('ctoSystemPrompt uses genuinely vertical slice examples, not horizontal layers', () => {
+        // Horizontal layer examples (internal plumbing only) must not appear
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"types + contracts"');
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"core logic"');
+        expect(managerPromptRegistry.ctoSystemPrompt).not.toContain('"plugin tools"');
+        // Prompt must describe the end-to-end / user-testable property of a slice
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('end-to-end');
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('user-testable');
+        // Horizontal layers must be explicitly called out as wrong
+        expect(managerPromptRegistry.ctoSystemPrompt).toContain('Horizontal layer');
+    });
 });

package/dist/test/team-orchestrator.test.js

@@ -44,7 +44,8 @@ describe('TeamOrchestrator', () => {
             outputTokens: 300,
             contextWindowSize: 200_000,
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        const store = new TeamStateStore('.state');
+        const orchestrator = new TeamOrchestrator({ runTask }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         const first = await orchestrator.dispatchEngineer({
             teamId: 'team-1',
             cwd: tempRoot,
@@ -78,6 +79,8 @@ describe('TeamOrchestrator', () => {
         expect(runTask.mock.calls[1]?.[0].systemPrompt).toBeUndefined();
         expect(runTask.mock.calls[1]?.[0].prompt).not.toContain('Assigned engineer: Tom.');
         expect(runTask.mock.calls[1]?.[0].prompt).toContain('Implement the chosen fix');
+        // Hybrid workflow: implement mode must include a pre-implementation plan step
+        expect(runTask.mock.calls[1]?.[0].prompt).toContain('state a brief implementation plan');
         const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
         expect(team.engineers.find((engineer) => engineer.name === 'Tom')).toMatchObject({
             claudeSessionId: 'ses_tom',
@@ -301,7 +304,8 @@ describe('TeamOrchestrator', () => {
                 contextWindowSize: 200_000,
             };
         });
-        const orchestrator = new TeamOrchestrator({ runTask }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        const store = new TeamStateStore('.state');
+        const orchestrator = new TeamOrchestrator({ runTask }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
         const allEvents = [];
         const result = await orchestrator.dispatchEngineer({
             teamId: 'team-1',
@@ -339,6 +343,158 @@ describe('TeamOrchestrator', () => {
         expect(error.message).toContain('BrowserQA is a browser QA specialist');
         expect(error.message).toContain('does not support implement mode');
     });
+    it('setActivePlan persists plan with slices on TeamRecord', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        const activePlan = await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Implement billing refactor in three slices',
+            taskSize: 'large',
+            slices: ['types + contracts', 'core logic', 'tests'],
+            preAuthorized: false,
+        });
+        expect(activePlan.id).toMatch(/^plan-/);
+        expect(activePlan.summary).toBe('Implement billing refactor in three slices');
+        expect(activePlan.taskSize).toBe('large');
+        expect(activePlan.preAuthorized).toBe(false);
+        expect(activePlan.slices).toHaveLength(3);
+        expect(activePlan.slices[0]).toMatchObject({
+            index: 0,
+            description: 'types + contracts',
+            status: 'pending',
+        });
+        expect(activePlan.slices[1]).toMatchObject({
+            index: 1,
+            description: 'core logic',
+            status: 'pending',
+        });
+        expect(activePlan.slices[2]).toMatchObject({
+            index: 2,
+            description: 'tests',
+            status: 'pending',
+        });
+        expect(activePlan.currentSliceIndex).toBe(0);
+        expect(activePlan.confirmedAt).not.toBeNull();
+        const retrieved = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(retrieved).toMatchObject({ id: activePlan.id, taskSize: 'large' });
+    });
+    it('clearActivePlan removes activePlan from TeamRecord', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Small task',
+            taskSize: 'simple',
+            slices: [],
+            preAuthorized: false,
+        });
+        const beforeClear = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(beforeClear).not.toBeNull();
+        await orchestrator.clearActivePlan(tempRoot, 'team-1');
+        const afterClear = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(afterClear).toBeNull();
+    });
+    it('updateActivePlanSlice marks a slice done and advances currentSliceIndex', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Two-slice task',
+            taskSize: 'large',
+            slices: ['slice A', 'slice B'],
+            preAuthorized: true,
+        });
+        await orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done');
+        const plan = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(plan).not.toBeNull();
+        expect(plan.slices[0]).toMatchObject({ index: 0, status: 'done' });
+        expect(plan.slices[0].completedAt).toBeDefined();
+        expect(plan.slices[1]).toMatchObject({ index: 1, status: 'pending' });
+        expect(plan.currentSliceIndex).toBe(1);
+    });
+    it('updateActivePlanSlice sets currentSliceIndex to null when the final slice is completed', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Single-slice task',
+            taskSize: 'large',
+            slices: ['ship the feature'],
+            preAuthorized: true,
+        });
+        // Complete the only slice (index 0, which is also the last)
+        await orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done');
+        const plan = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(plan).not.toBeNull();
+        expect(plan.slices[0]).toMatchObject({ index: 0, status: 'done' });
+        expect(plan.currentSliceIndex).toBeNull();
+    });
+    it('setActivePlan sets currentSliceIndex to null when no slices are provided', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        const plan = await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Simple no-slice task',
+            taskSize: 'simple',
+            slices: [],
+            preAuthorized: false,
+        });
+        expect(plan.currentSliceIndex).toBeNull();
+        expect(plan.slices).toHaveLength(0);
+    });
+    it('updateActivePlanSlice throws when team has no active plan', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await expect(orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done')).rejects.toThrow('has no active plan');
+    });
+    it('updateActivePlanSlice throws when slice index does not exist', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Two-slice task',
+            taskSize: 'large',
+            slices: ['slice A', 'slice B'],
+            preAuthorized: false,
+        });
+        // Index 5 does not exist (only 0 and 1 exist)
+        await expect(orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 5, 'done')).rejects.toThrow('slice index 5 does not exist');
+    });
+    it('updateActivePlanSlice throws when active plan has no slices', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'No-slice plan',
+            taskSize: 'simple',
+            slices: [],
+            preAuthorized: false,
+        });
+        await expect(orchestrator.updateActivePlanSlice(tempRoot, 'team-1', 0, 'done')).rejects.toThrow('plan has no slices');
+    });
+    it('getActivePlan returns null for a new team with no active plan', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        const plan = await orchestrator.getActivePlan(tempRoot, 'team-1');
+        expect(plan).toBeNull();
+    });
+    it('normalizeTeamRecord preserves activePlan from persisted records', async () => {
+        tempRoot = await mkdtemp(join(tmpdir(), 'team-orchestrator-'));
+        const store = new TeamStateStore('.state');
+        const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, store, { appendEvents: vi.fn(async () => { }) }, 'Base engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });
+        await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        await orchestrator.setActivePlan(tempRoot, 'team-1', {
+            summary: 'Persist test',
+            taskSize: 'simple',
+            slices: [],
+            preAuthorized: false,
+        });
+        // Re-read via getOrCreateTeam (triggers normalizeTeamRecord)
+        const team = await orchestrator.getOrCreateTeam(tempRoot, 'team-1');
+        expect(team.activePlan).toBeDefined();
+        expect(team.activePlan.summary).toBe('Persist test');
+    });
     it('selectPlanEngineers excludes BrowserQA from planner selection', async () => {
         tempRoot = await mkdtemp(join(tmpdir(), 'planner-exclude-browserqa-'));
         const orchestrator = new TeamOrchestrator({ runTask: vi.fn() }, new TeamStateStore('.state'), { appendEvents: vi.fn(async () => { }) }, 'Engineer prompt', 'Synthesis prompt', { BrowserQA: BROWSER_QA_TEST_CAPS });

package/dist/types/contracts.d.ts

@@ -116,6 +116,24 @@ export interface SessionContextSnapshot {
     warningLevel: ContextWarningLevel;
     compactionCount: number;
 }
+export type TaskSize = 'trivial' | 'simple' | 'large';
+export interface PlanSlice {
+    index: number;
+    description: string;
+    status: 'pending' | 'in_progress' | 'done' | 'skipped';
+    completedAt?: string;
+}
+export interface ActivePlan {
+    id: string;
+    summary: string;
+    taskSize: TaskSize;
+    createdAt: string;
+    confirmedAt: string | null;
+    preAuthorized: boolean;
+    slices: PlanSlice[];
+    /** Null when the plan has no slices (trivial/simple tasks). */
+    currentSliceIndex: number | null;
+}
 export interface TeamEngineerRecord {
     name: EngineerName;
     wrapperSessionId: string | null;
@@ -142,6 +160,7 @@ export interface TeamRecord {
     createdAt: string;
     updatedAt: string;
     engineers: TeamEngineerRecord[];
+    activePlan?: ActivePlan;
 }
 export interface EngineerTaskResult {
     teamId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.59",
+  "version": "0.1.60",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",