@@ -578,10 +578,16 @@ function App({ projectRoot, initialPrompt, resumeSessionId, forkSessionId, onRes
           setErrorLine("No active session to derive from.");
           return;
         }
+        let derivedSessionId: string | null = null;
+        let submissionStarted = false;
         try {
-          const sessionId = sessionManager.startPlanImplementationSession(sourceSessionId, proposedPlan);
+          const { sessionId, implementationPrompt } = await sessionManager.startPlanImplementationSession(
+            sourceSessionId,
+            proposedPlan
+          );
+          derivedSessionId = sessionId;
           sessionManager.setActiveSessionId(sessionId);
-          setPendingPlanImplementation(null);
+          processStdoutRef.current.clear();
           await resetStaticView(loadVisibleMessages(sessionManager, sessionId), { clearScreen: true });
           const session = sessionManager.getSession(sessionId);
           setStatusLine(session ? buildStatusLine(session, resolveCurrentSettings(projectRoot)) : "");
@@ -591,20 +597,35 @@ function App({ projectRoot, initialPrompt, resumeSessionId, forkSessionId, onRes
           setPlanMode(false);
           setPendingPermissionReply(null);
           setErrorLine(null);
-          const source = sessionManager.getSession(sourceSessionId);
-          if (source?.summary && !source.summary.includes(" (planned)")) {
-            sessionManager.renameSession(sourceSessionId, `${source.summary} (planned)`);
-          }
           refreshSessionsList();
           await refreshSkills(sessionId);
-          handleSubmit({
-            text: getImplementationPrompt(proposedPlan),
+          setPendingPlanImplementation(null);
+          submissionStarted = true;
+          await handlePrompt({
+            text: implementationPrompt,
             imageUrls: [],
             planMode: false,
           });
         } catch (error) {
+          if (submissionStarted) {
+            setErrorLine(error instanceof Error ? error.message : String(error));
+            return;
+          }
+          if (derivedSessionId) {
+            sessionManager.deleteSession(derivedSessionId);
+          }
+          sessionManager.setActiveSessionId(sourceSessionId);
+          processStdoutRef.current.clear();
+          await resetStaticView(loadVisibleMessages(sessionManager, sourceSessionId), { clearScreen: true });
+          const source = sessionManager.getSession(sourceSessionId);
+          setStatusLine(source ? buildStatusLine(source, resolveCurrentSettings(projectRoot)) : "");
+          setRunningProcesses(source?.processes ?? null);
+          setActiveStatus(source?.status ?? null);
+          setActiveAskPermissions(source?.askPermissions);
+          setPlanMode(true);
           setErrorLine(error instanceof Error ? error.message : String(error));
           setPendingPlanImplementation(proposedPlan);
+          refreshSessionsList();
         }
         return;
       }
@@ -620,6 +641,7 @@ function App({ projectRoot, initialPrompt, resumeSessionId, forkSessionId, onRes
     },
     [
       handleSubmit,
+      handlePrompt,
       pendingPlanImplementation,
       sessionManager,
       resetStaticView,
 
@@ -1,5 +1,6 @@
 import React, { useEffect, useState } from "react";
 import { Box, Text } from "ink";
+import { extractProposedPlan } from "@vegamo/deepcode-core";
 import { useTerminalInput } from "../hooks";
 import type { InputKey } from "../hooks";
 
@@ -16,14 +17,7 @@ const CHOICES: Array<{ value: PlanImplementationChoice; label: string }> = [
   { value: "clearContext", label: "clear context and implement this plan" },
 ];
 
-/** Return only a complete proposed plan, so historical or partial tags cannot trigger the chooser. */
-export function extractProposedPlan(reply: string | null): string | null {
-  if (!reply) {
-    return null;
-  }
-  const match = reply.match(/<proposed_plan>\s*([\s\S]*?\S[\s\S]*?)\s*<\/proposed_plan>/);
-  return match?.[1] ?? null;
-}
+export { extractProposedPlan };
 
 export function getImplementationPrompt(plan: string): string {
   const fullWidthPunctuationCount = (plan.match(/[，、；。]/g) ?? []).length;
 
@@ -41,7 +41,13 @@ export type {
 } from "./settings";
 
 // Session
-export { SessionManager, getProjectCode, getCompactPromptTokenThreshold } from "./session";
+export {
+  SessionManager,
+  buildPlanImplementationHandoff,
+  extractProposedPlan,
+  getProjectCode,
+  getCompactPromptTokenThreshold,
+} from "./session";
 export type {
   SessionMessage,
   SessionEntry,
@@ -58,6 +64,7 @@ export type {
   LlmStreamProgress,
   LlmRetryEvent,
   SessionManagerOptions,
+  PlanImplementationSessionResult,
 } from "./session";
 
 // Prompt utilities
 
@@ -108,7 +108,19 @@ const PLAN_MODE_FORCE_ASK_SCOPES = [
   "mutate-git-log",
 ] as const satisfies readonly PermissionScope[];
 
-function buildPlanImplementationMessage(planText: string): string {
+export function extractProposedPlan(content: string | null): string | null {
+  if (!content) {
+    return null;
+  }
+
+  let latestPlan: string | null = null;
+  for (const match of content.matchAll(/<proposed_plan>\s*([\s\S]*?\S[\s\S]*?)\s*<\/proposed_plan>/g)) {
+    latestPlan = match[1] ?? null;
+  }
+  return latestPlan;
+}
+
+export function buildPlanImplementationHandoff(planText: string): string {
   const fullWidthPunctuationCount = (planText.match(/[，、；。]/g) ?? []).length;
   const directive =
     fullWidthPunctuationCount > 5
@@ -300,6 +312,16 @@ export type SessionEntry = {
     sessionId: string;
     messageId: string;
   };
+  derivedFrom?: {
+    kind: "plan-implementation";
+    sessionId: string;
+    messageId: string;
+  };
+};
+
+export type PlanImplementationSessionResult = {
+  sessionId: string;
+  implementationPrompt: string;
 };
 
 export type SessionsIndex = {
@@ -317,7 +339,6 @@ export type MessageMeta = {
   asThinking?: boolean;
   isAnswers?: boolean;
   isSummary?: boolean;
-  isPlan?: boolean;
   isModelChange?: boolean;
   skill?: SkillInfo;
   skillCatalog?: Array<{ name: string; description: string }>;
@@ -395,7 +416,7 @@ export type SessionManagerOptions = {
   onLlmStreamProgress?: (progress: LlmStreamProgress) => void;
   onLlmRetry?: (event: LlmRetryEvent) => void;
   onMcpStatusChanged?: () => void;
-  onProcessStdout?: (pid: number, chunk: string) => void;
+  onProcessStdout?: (pid: number, chunk: string, sessionId: string) => void;
   loadSharp?: SharpLoader;
   nonInteractive?: boolean;
 };
@@ -442,7 +463,7 @@ export class SessionManager {
   private readonly onLlmStreamProgress?: (progress: LlmStreamProgress) => void;
   private readonly onLlmRetry?: (event: LlmRetryEvent) => void;
   private readonly onMcpStatusChanged?: () => void;
-  private readonly onProcessStdout?: (pid: number, chunk: string) => void;
+  private readonly onProcessStdout?: (pid: number, chunk: string, sessionId: string) => void;
   private readonly nonInteractive: boolean;
   private activeSessionId: string | null = null;
   private activePromptController: AbortController | null = null;
@@ -2336,30 +2357,67 @@ ${agentInstructions}
   /**
    * Derive a clean implementation session from a completed Plan Mode session.
    * Unlike forkSession (which copies the full conversation history), this builds a
-   * fresh message list carrying only the system prompt, runtime context, AGENTS.md
-   * instructions, and the approved plan — so implementation starts from a clean
-   * context while file history stays traceable to the source session's checkpoint.
+   * fresh trusted prefix carrying the current system prompt, runtime context,
+   * AGENTS.md instructions, and a compact current skill catalog. The caller submits
+   * the returned user-role handoff so implementation starts from a clean context
+   * while file history stays traceable to the source session's checkpoint.
    */
-  startPlanImplementationSession(sourceSessionId: string, planText: string): string {
+  async startPlanImplementationSession(
+    sourceSessionId: string,
+    expectedPlan: string
+  ): Promise<PlanImplementationSessionResult> {
     const source = this.getSession(sourceSessionId);
     if (!source) {
       throw new Error(`No saved session found with ID "${sourceSessionId}".`);
     }
     if (source.planMode !== true) {
       throw new Error(`Session "${sourceSessionId}" is not in Plan Mode.`);
     }
-
-    const trimmedPlanText = planText.trim();
-    if (!trimmedPlanText) {
+    if (source.status !== "completed") {
+      throw new Error(`Session "${sourceSessionId}" is not completed.`);
+    }
+    if (!expectedPlan.trim()) {
       throw new Error("The approved plan text must not be empty.");
     }
 
     const sourceMessages = this.listSessionMessages(sourceSessionId);
-    const sourceMessage = sourceMessages.at(-1);
-    if (!sourceMessage || typeof sourceMessage.id !== "string" || !sourceMessage.id) {
-      throw new Error(`Session "${sourceSessionId}" has no messages to derive from.`);
+    let sourceMessage: SessionMessage | undefined;
+    let planText: string | null = null;
+    for (let index = sourceMessages.length - 1; index >= 0; index -= 1) {
+      const message = sourceMessages[index];
+      if (message?.role !== "assistant") {
+        continue;
+      }
+      const proposedPlan = extractProposedPlan(message.content);
+      if (proposedPlan !== null) {
+        sourceMessage = message;
+        planText = proposedPlan;
+        break;
+      }
+    }
+    if (!sourceMessage || planText === null) {
+      throw new Error(`Session "${sourceSessionId}" has no complete proposed plan to implement.`);
+    }
+    if (expectedPlan !== planText) {
+      throw new Error("The approved plan no longer matches the latest proposed plan in the source session.");
     }
 
+    const advertisedSkillNames = new Set<string>();
+    for (const message of sourceMessages) {
+      if (message.meta?.skill?.name) {
+        advertisedSkillNames.add(message.meta.skill.name);
+      }
+      for (const skill of message.meta?.skillCatalog ?? []) {
+        if (skill?.name) {
+          advertisedSkillNames.add(skill.name);
+        }
+      }
+    }
+    const currentSkills = await this.listSkills();
+    const skillCatalog = currentSkills
+      .filter((skill) => advertisedSkillNames.has(skill.name))
+      .map((skill) => ({ name: skill.name, description: skill.description }));
+
     const sessionId = crypto.randomUUID();
     const now = new Date().toISOString();
     const entry: SessionEntry = {
@@ -2378,7 +2436,8 @@ ${agentInstructions}
       updateTime: now,
       processes: null,
       planMode: false,
-      forkedFrom: {
+      derivedFrom: {
+        kind: "plan-implementation",
         sessionId: sourceSessionId,
         messageId: sourceMessage.id,
       },
@@ -2401,19 +2460,21 @@ ${agentInstructions}
     if (agentInstructions) {
       messages.push(this.buildSystemMessage(sessionId, agentInstructions));
     }
-
-    messages.push(
-      this.buildSystemMessage(sessionId, buildPlanImplementationMessage(trimmedPlanText), null, false, {
-        isPlan: true,
-      })
-    );
+    if (skillCatalog.length > 0) {
+      messages.push(
+        this.buildSystemMessage(sessionId, buildSkillCatalogPrompt(skillCatalog), null, false, { skillCatalog })
+      );
+    }
 
     this.saveSessionMessages(sessionId, messages);
     this.getFileHistory().forkSession(sourceSessionId, sessionId);
 
     this.registerSessionEntry(entry);
 
-    return sessionId;
+    return {
+      sessionId,
+      implementationPrompt: buildPlanImplementationHandoff(planText),
+    };
   }
 
   /**
@@ -3167,7 +3228,7 @@ ${agentInstructions}
     const hooks: ToolExecutionHooks = {
       onProcessStart: (pid, command) => this.addSessionProcess(sessionId, pid, command),
       onProcessExit: (pid) => this.removeSessionProcess(sessionId, pid),
-      onProcessStdout: (pid, chunk) => this.onProcessStdout?.(Number(pid), chunk),
+      onProcessStdout: (pid, chunk) => this.onProcessStdout?.(Number(pid), chunk, sessionId),
       onProcessTimeoutControl: (pid, control) => this.setSessionProcessTimeoutControl(sessionId, pid, control),
       onBackgroundProcessComplete: (completion) => this.addBackgroundProcessCompletionMessage(sessionId, completion),
       onBeforeFileMutation: (filePath) => this.prepareFileMutationCheckpoint(sessionId, filePath),
@@ -3654,6 +3715,7 @@ ${agentInstructions}
       planMode: value.planMode === true,
       pluginRateLimitedTool: this.normalizePluginRateLimitedTool(value.pluginRateLimitedTool),
       forkedFrom: this.normalizeForkedFrom(value.forkedFrom),
+      derivedFrom: this.normalizeDerivedFrom(value.derivedFrom),
     };
   }
 
@@ -3680,6 +3742,27 @@ ${agentInstructions}
     };
   }
 
+  private normalizeDerivedFrom(value: unknown): SessionEntry["derivedFrom"] {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return undefined;
+    }
+    const derivedFrom = value as Record<string, unknown>;
+    if (
+      derivedFrom.kind !== "plan-implementation" ||
+      typeof derivedFrom.sessionId !== "string" ||
+      !derivedFrom.sessionId ||
+      typeof derivedFrom.messageId !== "string" ||
+      !derivedFrom.messageId
+    ) {
+      return undefined;
+    }
+    return {
+      kind: "plan-implementation",
+      sessionId: derivedFrom.sessionId,
+      messageId: derivedFrom.messageId,
+    };
+  }
+
   private normalizeSessionStatus(status: unknown): SessionStatus {
     if (
       status === "failed" ||