@beeos-ai/device-agent 0.15.0 → 0.16.1

package/dist/agent-runtime/plan-executor.js

@@ -1,6 +1,7 @@
 /**
  * agent-runtime/plan-executor — runs a structured Plan by spinning up
- * one `AgentLoop` per `PlanStep`.
+ * one `AgentLoop` per `PlanStep` for legacy callers. Pro instead executes
+ * the entire goal continuously, using plan steps only as guidance.
  *
  * This is the bridge between the *strategy* tier (`IPlanner`) and the
  * *act* tier (`AgentLoop` + `IModelAdapter` + `IMcpRuntime`):
@@ -49,6 +50,8 @@ const REPLAN_TERMINATORS = new Set([
 export class PlanExecutor {
     opts;
     deadline = Infinity;
+    signal;
+    progress;
     static DEFAULT_MAX_STEPS = 30;
     static DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
     static DEFAULT_MAX_REPLANS = 2;
@@ -56,12 +59,61 @@ export class PlanExecutor {
         this.opts = opts;
     }
     async run() {
+        const timeoutMs = this.opts.timeoutMs ?? PlanExecutor.DEFAULT_TIMEOUT_MS;
+        const budget = new AbortController();
+        this.deadline = Date.now() + timeoutMs;
+        this.signal = this.opts.signal ? AbortSignal.any([this.opts.signal, budget.signal]) : budget.signal;
+        const timer = setTimeout(() => budget.abort(new Error("Task deadline reached")), timeoutMs);
+        try {
+            const result = await this.runInternal();
+            this.progress = () => result;
+            this.signal.throwIfAborted();
+            return result;
+        }
+        catch (error) {
+            if (!this.signal.aborted)
+                throw error;
+            const cancelled = Boolean(this.opts.signal?.aborted);
+            return {
+                steps: 0, usage: { inputTokens: 0, outputTokens: 0 },
+                history: [], notes: [], plansEmitted: 0, replans: 0, reactFallbackUsed: false,
+                ...this.progress?.(),
+                ok: false,
+                finalText: cancelled ? "Task cancelled" : `plan executor exceeded ${timeoutMs}ms budget`,
+                terminator: cancelled ? "cancelled" : "timeout", cancelled,
+            };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    // Bound observation and supervisor waits, even if a provider ignores abort.
+    async bounded(operation) {
+        this.signal?.throwIfAborted();
+        const signal = this.signal;
+        let onAbort = () => { };
+        const interrupted = new Promise((_, reject) => {
+            onAbort = () => reject(signal.reason);
+            signal.addEventListener("abort", onAbort, { once: true });
+        });
+        try {
+            const result = await Promise.race([Promise.resolve().then(() => {
+                    signal.throwIfAborted();
+                    return operation();
+                }), interrupted]);
+            signal.throwIfAborted();
+            return result;
+        }
+        finally {
+            signal.removeEventListener("abort", onAbort);
+        }
+    }
+    async runInternal() {
         const maxSteps = this.opts.maxSteps ?? PlanExecutor.DEFAULT_MAX_STEPS;
         const timeoutMs = this.opts.timeoutMs ?? PlanExecutor.DEFAULT_TIMEOUT_MS;
         const maxReplans = this.opts.maxReplans ?? PlanExecutor.DEFAULT_MAX_REPLANS;
         const maxLocalRecoveries = this.opts.maxLocalRecoveries ?? 0;
-        const deadline = Date.now() + timeoutMs;
-        this.deadline = deadline;
+        const deadline = this.deadline;
         const reactFallback = this.opts.reactFallback ?? true;
         const usage = { inputTokens: 0, outputTokens: 0 };
         const history = [];
@@ -74,13 +126,9 @@ export class PlanExecutor {
         let pendingRecovery;
         let lastTerminator = "error";
         let lastFinalText = "";
-        /**
-         * Phase 2.2 / 2.3 — most recent non-`on_track` verdict from any inner
-         * AgentLoop. Threaded into the next `PlanContext.trajectoryVerdict`
-         * so the planner can pivot the plan rather than re-deriving the
-         * failure mode.
-         */
-        let lastTrajectoryVerdict;
+        this.progress = () => ({ ok: false, finalText: lastFinalText, steps: stepsConsumed,
+            usage, history, notes, plansEmitted, replans, reactFallbackUsed,
+            terminator: lastTerminator, cancelled: false });
         /**
          * KISS hardening — append-only feedback ring across the whole plan
          * run. Each inner AgentLoop's `feedbackLog` is concatenated here
@@ -99,15 +147,17 @@ export class PlanExecutor {
         // ReAct loop so the user-visible task can still make progress.
         let firstPlanRes;
         try {
-            firstPlanRes = await this.opts.planner.makePlan({
+            const observation = await this.snapshotForPlanner();
+            firstPlanRes = await this.bounded(() => this.opts.planner.makePlan({
                 goal: this.opts.goal,
                 history: [],
-                observation: await this.snapshotForPlanner(),
+                observation,
                 advancedKnowledge: this.opts.advancedKnowledge,
                 advancedTaskState: advancedTaskState?.render(),
-            }, { signal: this.opts.signal });
+            }, { signal: this.signal }));
         }
         catch (e) {
+            this.signal?.throwIfAborted();
             await this.fireError(`makePlan failed: ${errMsg(e)}`);
             if (reactFallback) {
                 const planFbRemaining = deadline - Date.now();
@@ -138,11 +188,11 @@ export class PlanExecutor {
                     observationMode: this.opts.observationMode,
                     maxSteps: Math.max(1, maxSteps - stepsConsumed),
                     timeoutMs: planFbRemaining,
-                    signal: this.opts.signal,
+                    signal: this.signal,
                     hooks: this.opts.hooks,
-                    reflector: this.opts.reflector,
+                    executionChecks: this.opts.executionChecks,
                 }).run();
-                await this.verifyFallback(fb);
+                this.signal?.throwIfAborted();
                 stepsConsumed += fb.steps;
                 accumulateUsage(usage, fb.usage);
                 history.push(...fb.history);
@@ -167,24 +217,13 @@ export class PlanExecutor {
         accumulateUsage(usage, firstPlanRes.usage);
         plansEmitted += 1;
         await this.firePlan(plan, /*isReplan*/ false, replans);
+        if (this.opts.advancedKnowledge && this.opts.adapter.nativeTools) {
+            return this.runContinuousPro(plan, usage, proMemory);
+        }
         // ── Main loop: walk the plan ───────────────────────────────────────
         let cur = 0;
         while (cur < plan.steps.length) {
-            if (this.opts.signal?.aborted) {
-                return this.finish({
-                    ok: false,
-                    finalText: "Task cancelled",
-                    stepsConsumed,
-                    usage,
-                    history,
-                    notes,
-                    plansEmitted,
-                    replans,
-                    reactFallbackUsed,
-                    terminator: "cancelled",
-                    cancelled: true,
-                });
-            }
+            this.signal?.throwIfAborted();
             if (Date.now() > deadline) {
                 return this.finish({
                     ok: false,
@@ -217,8 +256,13 @@ export class PlanExecutor {
                 });
             }
             const step = plan.steps[cur];
-            let subBudget = clamp(step.maxSteps ?? this.opts.perStepBudget ?? defaultPerStepBudget(plan.steps.length, maxSteps), 1, stepsLeft);
-            let innerTask = formatStepAsTask(this.opts.goal, plan, cur, this.opts.advancedKnowledge, advancedTaskState?.render(notes));
+            let subBudget = clamp(
+            // Native Pro milestones can be entire forms. Their default budget is
+            // shared globally, not evenly divided across unrelated milestones.
+            step.maxSteps ?? this.opts.perStepBudget ??
+                (this.opts.advancedKnowledge && this.opts.adapter.nativeTools
+                    ? stepsLeft : defaultPerStepBudget(plan.steps.length, maxSteps)), 1, stepsLeft);
+            let innerTask = formatStepAsTask(this.opts.goal, plan, cur, this.opts.advancedKnowledge, advancedTaskState?.render(notes), Boolean(this.opts.adapter.nativeTools));
             if (pendingRecovery) {
                 innerTask += `\n# LOCAL RECOVERY\n${pendingRecovery}\n` +
                     "Observe the current screen before acting. Repair only this sub-task: " +
@@ -255,6 +299,7 @@ export class PlanExecutor {
             }
             const result = await new AgentLoop({
                 task: innerTask,
+                taskContext: { rootGoal: this.opts.goal, currentMilestone: step.description },
                 proOperator: Boolean(this.opts.advancedKnowledge),
                 proMemory,
                 priorHistory: history,
@@ -264,16 +309,15 @@ export class PlanExecutor {
                 observationMode: this.opts.observationMode,
                 maxSteps: subBudget,
                 timeoutMs: innerRemaining,
-                signal: this.opts.signal,
+                signal: this.signal,
                 hooks: this.opts.hooks,
-                reflector: this.opts.reflector,
+                executionChecks: this.opts.executionChecks,
             }).run();
             stepsConsumed += result.steps;
             accumulateUsage(usage, result.usage);
             history.push(...result.history);
             notes.push(...result.notes);
-            if (result.trajectoryVerdict)
-                lastTrajectoryVerdict = result.trajectoryVerdict;
+            this.signal?.throwIfAborted();
             aggregatedFeedback.push(...result.feedbackLog);
             // Cap the buffer so a long-running plan with many failures doesn't
             // grow memory unboundedly — we only ever surface the last 3 entries
@@ -286,37 +330,6 @@ export class PlanExecutor {
             lastFinalText = result.finalText;
             let effectiveTerminator = result.terminator;
             let effectiveFinalText = result.finalText;
-            if (SUCCESS_TERMINATORS.has(result.terminator) && this.opts.subgoalVerifier) {
-                const verification = await this.opts.subgoalVerifier.verify({
-                    goal: this.opts.goal,
-                    plan,
-                    step,
-                    observation: await this.snapshotForPlanner(),
-                    recentHistory: history,
-                    executorMessage: result.finalText,
-                    advancedKnowledge: this.opts.advancedKnowledge,
-                }, this.opts.signal);
-                accumulateUsage(usage, verification.usage);
-                await this.fireSupervisorVerdict(step, verification);
-                if (verification.verdict === "unverified") {
-                    return this.finish({ ok: false, finalText: verification.reason, stepsConsumed, usage, history, notes,
-                        plansEmitted, replans, reactFallbackUsed, terminator: "error", cancelled: false });
-                }
-                // A subgoal verdict cannot skip remaining work or the root-goal audit.
-                if (verification.verdict === "not_achieved") {
-                    advancedTaskState?.recordRecovery({
-                        description: step.description,
-                        reason: verification.reason,
-                        guidance: verification.guidance,
-                    });
-                    effectiveTerminator = "reflection_veto";
-                    effectiveFinalText = [verification.reason, verification.guidance]
-                        .filter(Boolean)
-                        .join("; ");
-                    lastTerminator = effectiveTerminator;
-                    lastFinalText = effectiveFinalText;
-                }
-            }
             if (SUCCESS_TERMINATORS.has(effectiveTerminator)) {
                 advancedTaskState?.recordCompleted({
                     description: step.description,
@@ -400,8 +413,7 @@ export class PlanExecutor {
                     notes: notes.length > 0 ? [...notes] : undefined,
                     // Phase 2.2 / 2.3 — surface the most recent trajectory verdict so
                     // the planner can react to "off_track" / "stuck" explicitly.
-                    trajectoryVerdict: lastTrajectoryVerdict,
-                    // KISS hardening — surface the last 3 reflector feedback entries
+                    // KISS hardening — surface the last 3 executionChecks feedback entries
                     // accumulated across **all** sub-tasks so the planner sees the
                     // precise failure trail (pre-sanity vetoes, MCP failures,
                     // trajectory verdicts) rather than having to parse
@@ -410,7 +422,7 @@ export class PlanExecutor {
                     failureChain: aggregatedFeedback.length > 0 ? aggregatedFeedback.slice(-3) : undefined,
                 };
                 try {
-                    const repl = await this.opts.planner.replan(ctx, { signal: this.opts.signal });
+                    const repl = await this.bounded(() => this.opts.planner.replan(ctx, { signal: this.signal }));
                     accumulateUsage(usage, repl.usage);
                     plan = repl.plan;
                     plansEmitted += 1;
@@ -419,6 +431,7 @@ export class PlanExecutor {
                     continue;
                 }
                 catch (e) {
+                    this.signal?.throwIfAborted();
                     // planner blew up — fall through to ReAct fallback
                     await this.fireError(`replan failed: ${errMsg(e)}`);
                 }
@@ -454,11 +467,11 @@ export class PlanExecutor {
                     observationMode: this.opts.observationMode,
                     maxSteps: Math.max(1, maxSteps - stepsConsumed),
                     timeoutMs: fbRemaining,
-                    signal: this.opts.signal,
+                    signal: this.signal,
                     hooks: this.opts.hooks,
-                    reflector: this.opts.reflector,
+                    executionChecks: this.opts.executionChecks,
                 }).run();
-                await this.verifyFallback(fallback);
+                this.signal?.throwIfAborted();
                 stepsConsumed += fallback.steps;
                 accumulateUsage(usage, fallback.usage);
                 history.push(...fallback.history);
@@ -510,7 +523,79 @@ export class PlanExecutor {
             cancelled: false,
         });
     }
+    async runContinuousPro(plan, usage, memory) {
+        const history = [];
+        const notes = [];
+        const maxSteps = this.opts.maxSteps ?? PlanExecutor.DEFAULT_MAX_STEPS;
+        const maxReplans = this.opts.maxReplans ?? PlanExecutor.DEFAULT_MAX_REPLANS;
+        let stepsConsumed = 0;
+        let replans = 0;
+        let plansEmitted = 1;
+        let finalText = "";
+        let terminator = "error";
+        this.progress = () => ({ ok: false, finalText, steps: stepsConsumed, usage, history,
+            notes, plansEmitted, replans, reactFallbackUsed: false, terminator, cancelled: false });
+        while (stepsConsumed < maxSteps) {
+            this.signal?.throwIfAborted();
+            const remaining = this.deadline - Date.now();
+            if (remaining <= 0) {
+                terminator = "timeout";
+                finalText = "Task deadline reached";
+                break;
+            }
+            const result = await new AgentLoop({
+                task: this.opts.goal,
+                taskContext: { rootGoal: this.opts.goal, currentMilestone: this.opts.goal },
+                operatorGuidance: `Plan guidance (not separate tasks):\n${describePlan(plan)}\n` +
+                    "Keep working on the ORIGINAL full task. Completing a milestone only updates progress; " +
+                    "it does not finish this task. Record completed work and requested facts with take_note. " +
+                    "Handle local blockers and alternative routes yourself. Finish only when the whole task " +
+                    "is satisfied, or report a concrete blocker honestly. Preserve prior completed work.\n" +
+                    (this.opts.advancedKnowledge ?? ""),
+                proOperator: true, proMemory: memory, priorHistory: history,
+                env: this.opts.env, mcp: this.opts.mcp, adapter: this.opts.adapter,
+                observationMode: this.opts.observationMode,
+                maxSteps: maxSteps - stepsConsumed, timeoutMs: remaining,
+                signal: this.signal, hooks: this.opts.hooks, executionChecks: this.opts.executionChecks,
+            }).run();
+            stepsConsumed += result.steps;
+            accumulateUsage(usage, result.usage);
+            history.push(...result.history);
+            notes.push(...result.notes);
+            finalText = result.finalText;
+            terminator = result.terminator;
+            this.signal?.throwIfAborted();
+            if (SUCCESS_TERMINATORS.has(terminator) || terminator === "call_for_user" ||
+                terminator === "cancelled" || stepsConsumed >= maxSteps ||
+                !REPLAN_TERMINATORS.has(terminator) || replans >= maxReplans)
+                break;
+            replans += 1;
+            try {
+                const observation = await this.snapshotForPlanner();
+                const revised = await this.bounded(() => this.opts.planner.replan({
+                    goal: this.opts.goal, previousPlan: plan, observation, history,
+                    notes: [...notes], advancedKnowledge: this.opts.advancedKnowledge,
+                    failureReason: `Whole-task operator stopped with ${terminator}: ${finalText}. ` +
+                        "Revise the route, preserving completed work and collected facts.",
+                    failureChain: result.feedbackLog.slice(-3),
+                }, { signal: this.signal }));
+                accumulateUsage(usage, revised.usage);
+                plan = revised.plan;
+                plansEmitted += 1;
+                await this.firePlan(plan, true, replans);
+            }
+            catch (error) {
+                this.signal?.throwIfAborted();
+                await this.fireError(`replan failed: ${errMsg(error)}`);
+                break;
+            }
+        }
+        return this.finish({ ok: SUCCESS_TERMINATORS.has(terminator), finalText,
+            stepsConsumed, usage, history, notes, plansEmitted, replans,
+            reactFallbackUsed: false, terminator, cancelled: terminator === "cancelled" });
+    }
     async firePlan(plan, isReplan, replanCount) {
+        this.signal?.throwIfAborted();
         if (!this.opts.hooks?.onReasoning)
             return;
         try {
@@ -521,6 +606,7 @@ export class PlanExecutor {
         }
     }
     async fireError(message) {
+        this.signal?.throwIfAborted();
         if (!this.opts.hooks?.onError)
             return;
         try {
@@ -530,57 +616,79 @@ export class PlanExecutor {
             // ditto
         }
     }
-    async verifyFallback(result) {
-        if (!this.opts.subgoalVerifier || !SUCCESS_TERMINATORS.has(result.terminator))
-            return;
-        const step = { idx: 1, description: this.opts.goal, expectedOutcome: this.opts.goal };
-        const verification = await this.opts.subgoalVerifier.verify({ goal: this.opts.goal,
-            plan: { goal: this.opts.goal, steps: [step] }, step, observation: await this.snapshotForPlanner(),
-            recentHistory: result.history, executorMessage: result.finalText, advancedKnowledge: this.opts.advancedKnowledge,
-        }, this.opts.signal);
-        accumulateUsage(result.usage, verification.usage);
-        await this.fireSupervisorVerdict(step, verification);
-        if (verification.verdict === "unverified" || verification.verdict === "not_achieved") {
-            result.terminator = verification.verdict === "unverified" ? "error" : "reflection_veto";
-            result.finalText = verification.reason;
-        }
-    }
-    async fireSupervisorVerdict(step, verification) {
-        if (!this.opts.hooks?.onReasoning || verification.verdict === "achieved")
-            return;
-        try {
-            const guidance = verification.guidance ? `; guidance: ${verification.guidance}` : "";
-            await this.opts.hooks.onReasoning(`[supervisor] subgoal ${step.idx}: ${verification.verdict} — ${verification.reason}${guidance}\n`);
-        }
-        catch {
-            // Observability hooks never control execution.
-        }
-    }
     async finish(args) {
-        if (args.ok && this.opts.subgoalVerifier) {
+        const policy = this.opts.resultVerification ?? "final";
+        if (args.ok && (this.opts.advancedKnowledge || this.opts.resultVerification) && policy !== "off" && !this.opts.subgoalVerifier) {
+            args.ok = false;
+            args.terminator = "error";
+            args.finalText = `Original task completion could not be verified: no result checker configured\nExecutor report (unverified): ${args.finalText}`;
+        }
+        if (args.ok && this.opts.subgoalVerifier && policy !== "off") {
+            let rejected = false;
+            let deficiency = "";
             try {
-                this.opts.signal?.throwIfAborted();
-                const remaining = this.deadline - Date.now();
-                if (remaining <= 0)
-                    throw new Error("Task deadline reached before final audit");
-                const timeout = AbortSignal.timeout(Math.ceil(remaining));
-                const signal = this.opts.signal ? AbortSignal.any([this.opts.signal, timeout]) : timeout;
-                const step = { idx: 1, description: this.opts.goal, expectedOutcome: this.opts.goal };
-                const audit = await this.opts.subgoalVerifier.verify({ scope: "task", goal: this.opts.goal,
-                    plan: { goal: this.opts.goal, steps: [step] }, step, observation: await this.snapshotForPlanner(),
-                    recentHistory: args.history, executorMessage: args.finalText, notes: args.notes,
-                }, signal);
-                signal.throwIfAborted();
-                accumulateUsage(args.usage, audit.usage);
-                args.ok = audit.verdict === "task_complete" && Boolean(audit.finalAnswer?.trim());
-                args.finalText = audit.finalAnswer || audit.reason;
-                args.terminator = args.ok ? "done" : audit.verdict === "not_achieved" ? "reflection_veto" : "error";
+                for (let attempt = 0; attempt < 2; attempt++) {
+                    this.signal?.throwIfAborted();
+                    const remaining = this.deadline - Date.now();
+                    if (remaining <= 0)
+                        throw new Error("Task deadline reached before final audit");
+                    const signal = this.signal;
+                    const step = { idx: 1, description: this.opts.goal, expectedOutcome: this.opts.goal };
+                    const observation = await this.snapshotForPlanner();
+                    const verifier = this.opts.subgoalVerifier;
+                    const audit = await this.bounded(() => verifier.verify({ scope: "task", goal: this.opts.goal,
+                        plan: { goal: this.opts.goal, steps: [step] }, step, observation,
+                        recentHistory: args.history, executorMessage: args.finalText, notes: args.notes,
+                    }, signal));
+                    signal.throwIfAborted();
+                    accumulateUsage(args.usage, audit.usage);
+                    if (audit.verdict === "task_complete") {
+                        args.finalText = audit.finalAnswer?.trim() || args.finalText;
+                        rejected = false;
+                        args.ok = true;
+                        args.terminator = "done";
+                        break;
+                    }
+                    if (audit.verdict !== "not_achieved")
+                        throw new Error(audit.reason || "No conclusive verification");
+                    rejected = true;
+                    deficiency = audit.reason;
+                    args.ok = false;
+                    args.terminator = "reflection_veto";
+                    args.finalText = audit.finalAnswer || audit.reason;
+                    const repairSteps = (this.opts.maxSteps ?? PlanExecutor.DEFAULT_MAX_STEPS) - args.stepsConsumed;
+                    if (attempt > 0 || repairSteps <= 0)
+                        break;
+                    // Repair only concrete missing requirements, never a checker outage.
+                    const repair = await new AgentLoop({
+                        task: `Original task: ${this.opts.goal}\nRepair ONLY this verified deficiency: ${audit.reason}\n${audit.guidance ?? ""}\nDo not repeat already completed operations.`,
+                        taskContext: { rootGoal: this.opts.goal, currentMilestone: audit.reason },
+                        priorHistory: args.history, proOperator: Boolean(this.opts.adapter.nativeTools || this.opts.advancedKnowledge),
+                        env: this.opts.env, mcp: this.opts.mcp, adapter: this.opts.adapter,
+                        observationMode: this.opts.observationMode, maxSteps: repairSteps,
+                        timeoutMs: Math.max(1, this.deadline - Date.now()), signal: this.signal,
+                        hooks: this.opts.hooks, executionChecks: this.opts.executionChecks,
+                    }).run();
+                    args.stepsConsumed += repair.steps;
+                    accumulateUsage(args.usage, repair.usage);
+                    args.history.push(...repair.history);
+                    args.notes.push(...repair.notes);
+                    this.signal?.throwIfAborted();
+                    if (!SUCCESS_TERMINATORS.has(repair.terminator)) {
+                        args.terminator = repair.terminator;
+                        args.finalText = repair.finalText;
+                        args.cancelled = repair.cancelled;
+                        break;
+                    }
+                    args.finalText = repair.finalText;
+                }
             }
             catch (error) {
-                args.ok = false;
                 args.cancelled = Boolean(this.opts.signal?.aborted);
-                args.terminator = args.cancelled ? "cancelled" : Date.now() >= this.deadline ? "timeout" : "error";
-                args.finalText = `Original task completion could not be verified: ${errMsg(error)}`;
+                const deadlineReached = Date.now() >= this.deadline || Boolean(this.signal?.aborted);
+                args.ok = false;
+                args.terminator = args.cancelled ? "cancelled" : deadlineReached ? "timeout" : rejected ? "reflection_veto" : "error";
+                args.finalText = `${deficiency ? `Unresolved requirement: ${deficiency}. ` : ""}Original task completion could not be verified: ${errMsg(error)}\nExecutor report (unverified): ${args.finalText}`;
             }
         }
         return {
@@ -605,6 +713,9 @@ export class PlanExecutor {
      * cannot be collected.
      */
     async snapshotForPlanner() {
+        return this.bounded(() => this.collectSnapshotForPlanner());
+    }
+    async collectSnapshotForPlanner() {
         if (this.opts.observationMode === "xml") {
             let uiDump;
             try {
@@ -704,7 +815,7 @@ function errMsg(e) {
  * goal it serves and what the upcoming sub-tasks look like, but the
  * primary instruction is still the current step's description.
  */
-function formatStepAsTask(rootGoal, plan, idx, advancedKnowledge, advancedTaskState) {
+function formatStepAsTask(rootGoal, plan, idx, advancedKnowledge, advancedTaskState, nativeOperator = false) {
     const step = plan.steps[idx];
     const advanced = Boolean(advancedKnowledge);
     const upcoming = plan.steps
@@ -718,8 +829,11 @@ function formatStepAsTask(rootGoal, plan, idx, advancedKnowledge, advancedTaskSt
     // supervisor tiers retain the root goal, while the mobile actor sees only
     // one grounded subgoal. Showing AutoGLM the root goal causes it to race
     // ahead and execute later plan items inside the current child loop.
+    // Native Pro needs the original literal field values as reference data;
+    // its current-subtask scope still forbids executing later milestones.
     const goalLine = advanced
-        ? "# Scope: execute exactly one planner-assigned sub-task."
+        ? "# Scope: execute exactly one planner-assigned sub-task." +
+            (nativeOperator ? `\n# Original request (reference constraints only, not permission to execute later sub-tasks):\n${rootGoal}` : "")
         : `# Goal: ${rootGoal}`;
     const scopeRule = advanced
         ? [