@narumitw/pi-plan-mode 0.51.1 → 0.52.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +30 -0
- package/dist/index.ts +275 -75
- package/dist/index.ts.map +3 -3
- package/package.json +1 -1
- package/src/plan-mode.ts +233 -70
- package/src/workflow-mutex.ts +87 -0
package/README.md
CHANGED
|
@@ -15,6 +15,7 @@ This independently installable extension adds a Codex-like `/plan` collaboration
|
|
|
15
15
|
- Starts implementation in the planning session or a fresh linked session with the exact approved plan.
|
|
16
16
|
- Persists Plan state and one saved plan across resume and compaction.
|
|
17
17
|
- Exposes statusline state and configurable tool visibility, export destination, handoff behavior, shortcut, and thinking level.
|
|
18
|
+
- Cooperates anonymously with Workflow Mutex Protocol v1 participants so only one agent workflow starts in a session.
|
|
18
19
|
|
|
19
20
|
## 📦 Install
|
|
20
21
|
|
|
@@ -221,6 +222,35 @@ During implementation, it removes both the original implementation handoff and t
|
|
|
221
222
|
/plan exit
|
|
222
223
|
```
|
|
223
224
|
|
|
225
|
+
## 🤝 Workflow coexistence
|
|
226
|
+
|
|
227
|
+
Plan mode is independently installable and keeps its standalone behavior when no other protocol participant is present.
|
|
228
|
+
On the characterized Pi `0.84.2` runtime, it participates in the anonymous `workflow:mutex:v1` `agent-workflow` group.
|
|
229
|
+
It holds the group while Planning is active, while a completed plan awaits review, and while revision is underway.
|
|
230
|
+
Saved plans and ordinary implementation after Plan handoff do not hold the group.
|
|
231
|
+
|
|
232
|
+
Every inactive start performs one final synchronous admission after asynchronous preflight and before changing Plan state, persistence, prompts, tools, thinking level, queues, or status.
|
|
233
|
+
If another participant is active, TUI and RPC show an anonymous warning that another workflow is active.
|
|
234
|
+
Print and JSON direct routes throw the same anonymous error before mutation.
|
|
235
|
+
Launch-menu, selected-tool, shortcut, startup-flag, active-implementation **Start a new plan**, and restored activation use the same admission boundary.
|
|
236
|
+
A rejected selected-tool launch does not save its draft choices.
|
|
237
|
+
|
|
238
|
+
Restored active Plan state acquires before restoring restrictive tools, thinking, status, or model hooks.
|
|
239
|
+
If restoration is busy, Plan mode stays non-running, leaves persisted history untouched, does not alter active tools, and requires a later reload or explicit new start after the other workflow ends.
|
|
240
|
+
Planning-session cancellation during a fresh implementation preflight keeps the source Plan and its ownership.
|
|
241
|
+
Successful session replacement relies on source-session shutdown to clean up and release; the destination's ordinary active implementation does not acquire the Plan mutex.
|
|
242
|
+
|
|
243
|
+
The coexistence guarantee is cooperative and applies only when every contender implements v1 on the characterized Pi runtime and shares its event bus and session-manager identity.
|
|
244
|
+
A pre-v1, mixed-version, non-participating, forked, or otherwise uncharacterized counterpart remains unsupported for mutual exclusion.
|
|
245
|
+
Plan mode does not identify, inspect, configure, start, stop, or depend on another extension.
|
|
246
|
+
Guaranteed coexistence with Goal requires `@narumitw/pi-goal` `0.53.0` or newer and this package at `0.52.0` or newer on the characterized Pi `0.84.2` runtime.
|
|
247
|
+
|
|
248
|
+
| Installation | Support |
|
|
249
|
+
| --- | --- |
|
|
250
|
+
| Plan mode without another workflow participant | Supported standalone behavior |
|
|
251
|
+
| Plan mode `>=0.52.0` with Goal `>=0.53.0` on Pi `0.84.2` | Workflow Mutex v1 coexistence guarantee |
|
|
252
|
+
| Either package below its floor, or another Pi runtime | Standalone behavior only; mutual exclusion unsupported |
|
|
253
|
+
|
|
224
254
|
## 🛠️ Tools
|
|
225
255
|
|
|
226
256
|
- `plan_mode_question` asks up to three structured questions, supports optional answer notes, submits one answer directly, and reviews multiple answers before TUI submission.
|
package/dist/index.ts
CHANGED
|
@@ -592,12 +592,78 @@ function isRecord(value) {
|
|
|
592
592
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
593
593
|
}
|
|
594
594
|
|
|
595
|
+
// src/workflow-mutex.ts
|
|
596
|
+
var WORKFLOW_MUTEX_CHANNEL = "workflow:mutex:v1";
|
|
597
|
+
var AGENT_WORKFLOW_GROUP = "agent-workflow";
|
|
598
|
+
var WorkflowMutex = class {
|
|
599
|
+
constructor(pi) {
|
|
600
|
+
this.pi = pi;
|
|
601
|
+
pi.events.on(WORKFLOW_MUTEX_CHANNEL, (payload) => {
|
|
602
|
+
this.answer(payload);
|
|
603
|
+
});
|
|
604
|
+
}
|
|
605
|
+
pi;
|
|
606
|
+
session;
|
|
607
|
+
heldGroups = /* @__PURE__ */ new Map();
|
|
608
|
+
generation = 0;
|
|
609
|
+
bindSession(session) {
|
|
610
|
+
this.generation += 1;
|
|
611
|
+
this.heldGroups.clear();
|
|
612
|
+
this.session = session;
|
|
613
|
+
}
|
|
614
|
+
unbindSession(session) {
|
|
615
|
+
if (this.session !== session) return;
|
|
616
|
+
this.generation += 1;
|
|
617
|
+
this.heldGroups.clear();
|
|
618
|
+
this.session = void 0;
|
|
619
|
+
}
|
|
620
|
+
acquire(group = AGENT_WORKFLOW_GROUP) {
|
|
621
|
+
const session = this.session;
|
|
622
|
+
const generation = this.generation;
|
|
623
|
+
if (!session || this.heldGroups.has(group)) return void 0;
|
|
624
|
+
const attempt = { session, group, busy: false };
|
|
625
|
+
try {
|
|
626
|
+
this.pi.events.emit(WORKFLOW_MUTEX_CHANNEL, attempt);
|
|
627
|
+
} catch {
|
|
628
|
+
return void 0;
|
|
629
|
+
}
|
|
630
|
+
if (this.session !== session || this.generation !== generation || attempt.session !== session || attempt.group !== group || attempt.busy !== false || this.heldGroups.has(group)) {
|
|
631
|
+
return void 0;
|
|
632
|
+
}
|
|
633
|
+
const owner = Symbol(group);
|
|
634
|
+
this.heldGroups.set(group, owner);
|
|
635
|
+
return owner;
|
|
636
|
+
}
|
|
637
|
+
isOwner(owner, group = AGENT_WORKFLOW_GROUP) {
|
|
638
|
+
return owner !== void 0 && this.heldGroups.get(group) === owner;
|
|
639
|
+
}
|
|
640
|
+
release(owner, group = AGENT_WORKFLOW_GROUP) {
|
|
641
|
+
if (!this.isOwner(owner, group)) return;
|
|
642
|
+
this.heldGroups.delete(group);
|
|
643
|
+
}
|
|
644
|
+
answer(payload) {
|
|
645
|
+
try {
|
|
646
|
+
if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return;
|
|
647
|
+
const attempt = payload;
|
|
648
|
+
if (attempt.session !== this.session) return;
|
|
649
|
+
if (attempt.group !== AGENT_WORKFLOW_GROUP) return;
|
|
650
|
+
if (typeof attempt.busy !== "boolean") return;
|
|
651
|
+
if (!this.heldGroups.has(attempt.group)) return;
|
|
652
|
+
attempt.busy = true;
|
|
653
|
+
} catch {
|
|
654
|
+
}
|
|
655
|
+
}
|
|
656
|
+
};
|
|
657
|
+
|
|
595
658
|
// src/plan-mode.ts
|
|
596
659
|
var STATE_ENTRY_TYPE = "plan-mode-state";
|
|
597
660
|
var PROPOSED_PLAN_MESSAGE_TYPE = "proposed-plan";
|
|
598
661
|
var BLOCKED_BUILTIN_TOOLS = /* @__PURE__ */ new Set(["edit", "write"]);
|
|
599
662
|
var DEFAULT_TOOLS = ["read", "bash", "edit", "write"];
|
|
600
663
|
function planMode(pi, dependencies = {}) {
|
|
664
|
+
const workflowMutex = new WorkflowMutex(pi);
|
|
665
|
+
let workflowOwner;
|
|
666
|
+
let currentSession;
|
|
601
667
|
let interactiveUiPromise;
|
|
602
668
|
const loadInteractiveUi = () => {
|
|
603
669
|
if (dependencies.loadInteractiveUi) return dependencies.loadInteractiveUi();
|
|
@@ -671,7 +737,7 @@ function planMode(pi, dependencies = {}) {
|
|
|
671
737
|
],
|
|
672
738
|
parameters: PLAN_MODE_QUESTION_PARAMS,
|
|
673
739
|
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
|
674
|
-
if (!state.enabled) {
|
|
740
|
+
if (!state.enabled || !workflowMutex.isOwner(workflowOwner)) {
|
|
675
741
|
return planModeQuestionCancelled(
|
|
676
742
|
[],
|
|
677
743
|
"plan_mode_inactive",
|
|
@@ -691,8 +757,9 @@ function planMode(pi, dependencies = {}) {
|
|
|
691
757
|
}
|
|
692
758
|
const sessionGeneration = menuGeneration;
|
|
693
759
|
const questionWorkflowGeneration = workflowGeneration;
|
|
760
|
+
const questionOwner = workflowOwner;
|
|
694
761
|
return answerPlanModeQuestions(parsed.questions, ctx, {
|
|
695
|
-
isCurrent: () => sessionGeneration === menuGeneration && questionWorkflowGeneration === workflowGeneration,
|
|
762
|
+
isCurrent: () => sessionGeneration === menuGeneration && questionWorkflowGeneration === workflowGeneration && workflowMutex.isOwner(questionOwner),
|
|
696
763
|
isEnabled: () => state.enabled
|
|
697
764
|
});
|
|
698
765
|
}
|
|
@@ -708,7 +775,7 @@ function planMode(pi, dependencies = {}) {
|
|
|
708
775
|
parameters: PLAN_MODE_COMPLETE_PARAMS,
|
|
709
776
|
renderResult: renderPlanModeCompletion,
|
|
710
777
|
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
|
711
|
-
if (!state.enabled) {
|
|
778
|
+
if (!state.enabled || !workflowMutex.isOwner(workflowOwner)) {
|
|
712
779
|
throw new Error("plan_mode_complete is only available while Plan mode is active");
|
|
713
780
|
}
|
|
714
781
|
const parsed = normalizePlanModeCompletion(params);
|
|
@@ -731,8 +798,12 @@ function planMode(pi, dependencies = {}) {
|
|
|
731
798
|
ctx.ui.notify("Plan mode is already active.", "info");
|
|
732
799
|
return;
|
|
733
800
|
}
|
|
734
|
-
enterPlanMode(ctx)
|
|
735
|
-
|
|
801
|
+
if (enterPlanMode(ctx)) {
|
|
802
|
+
ctx.ui.notify(
|
|
803
|
+
"Plan mode enabled. I will explore and plan, but not modify files.",
|
|
804
|
+
"info"
|
|
805
|
+
);
|
|
806
|
+
}
|
|
736
807
|
return;
|
|
737
808
|
}
|
|
738
809
|
if (command === "show") {
|
|
@@ -889,35 +960,35 @@ function planMode(pi, dependencies = {}) {
|
|
|
889
960
|
};
|
|
890
961
|
pi.on("session_start", async (event, ctx) => {
|
|
891
962
|
const generation = ++menuGeneration;
|
|
963
|
+
currentSession = ctx.sessionManager;
|
|
964
|
+
workflowOwner = void 0;
|
|
965
|
+
workflowMutex.bindSession(ctx.sessionManager);
|
|
892
966
|
refreshStateBeforeFirstAgentStart = event.reason === "new";
|
|
893
967
|
menuController.abort(new DOMException("Plan-mode session replaced", "AbortError"));
|
|
894
968
|
menuController = new AbortController();
|
|
895
969
|
readyPresentationIntent = void 0;
|
|
896
970
|
latestCommandContext = void 0;
|
|
971
|
+
previousTools = void 0;
|
|
897
972
|
implementationRetention.reset();
|
|
898
973
|
settings = { thinkingLevel: "inherit" };
|
|
899
|
-
|
|
900
|
-
|
|
974
|
+
const restoredState = readRestoredState(ctx);
|
|
975
|
+
state = { enabled: false, awaitingAction: false };
|
|
901
976
|
await applyPlanModeSettings(generation, ctx, true);
|
|
902
977
|
if (generation !== menuGeneration || menuController.signal.aborted) return;
|
|
903
978
|
startPlanModeSettingsWatch(generation);
|
|
904
|
-
const persistFlagActivation = pi.getFlag("plan") === true && !
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
910
|
-
|
|
911
|
-
|
|
912
|
-
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
|
|
916
|
-
if (state.enabled)
|
|
917
|
-
activatePlanModeTools();
|
|
918
|
-
applyPlanThinkingLevel();
|
|
919
|
-
} else deactivatePlanModeQuestionTool();
|
|
920
|
-
if (persistFlagActivation) persistState();
|
|
979
|
+
const persistFlagActivation = pi.getFlag("plan") === true && !restoredState.enabled;
|
|
980
|
+
const candidate = persistFlagActivation ? restoredState.savedPlan ? {
|
|
981
|
+
...restoredState,
|
|
982
|
+
enabled: true,
|
|
983
|
+
latestPlan: restoredState.savedPlan.plan,
|
|
984
|
+
latestPlanSource: restoredState.savedPlan.source,
|
|
985
|
+
awaitingAction: true,
|
|
986
|
+
savedPlan: void 0,
|
|
987
|
+
activeImplementation: void 0
|
|
988
|
+
} : { ...restoredState, enabled: true, activeImplementation: void 0 } : restoredState;
|
|
989
|
+
if (!installRestoredState(candidate, ctx)) return;
|
|
990
|
+
implementationRetention.restore(state.activeImplementation);
|
|
991
|
+
if (persistFlagActivation && state.enabled) persistState();
|
|
921
992
|
updateUi(ctx);
|
|
922
993
|
});
|
|
923
994
|
pi.on("thinking_level_select", (event) => {
|
|
@@ -933,6 +1004,7 @@ function planMode(pi, dependencies = {}) {
|
|
|
933
1004
|
}
|
|
934
1005
|
});
|
|
935
1006
|
pi.on("session_shutdown", async (_event, ctx) => {
|
|
1007
|
+
const shutdownSession = ctx.sessionManager;
|
|
936
1008
|
menuGeneration += 1;
|
|
937
1009
|
menuController.abort(new DOMException("Plan-mode session shut down", "AbortError"));
|
|
938
1010
|
readyPresentationIntent = void 0;
|
|
@@ -940,6 +1012,10 @@ function planMode(pi, dependencies = {}) {
|
|
|
940
1012
|
refreshStateBeforeFirstAgentStart = false;
|
|
941
1013
|
implementationRetention.reset();
|
|
942
1014
|
await awaitPlanModeSettingsWrites(dependencies.settingsPath);
|
|
1015
|
+
if (currentSession !== void 0 && currentSession !== shutdownSession) {
|
|
1016
|
+
workflowMutex.unbindSession(shutdownSession);
|
|
1017
|
+
return;
|
|
1018
|
+
}
|
|
943
1019
|
captureManualThinkingLevel();
|
|
944
1020
|
persistState();
|
|
945
1021
|
if (state.enabled) {
|
|
@@ -948,9 +1024,12 @@ function planMode(pi, dependencies = {}) {
|
|
|
948
1024
|
}
|
|
949
1025
|
stopPlanModeSettingsWatch();
|
|
950
1026
|
clearUi(ctx);
|
|
1027
|
+
releaseWorkflowOwner();
|
|
1028
|
+
workflowMutex.unbindSession(ctx.sessionManager);
|
|
1029
|
+
if (currentSession === ctx.sessionManager) currentSession = void 0;
|
|
951
1030
|
});
|
|
952
1031
|
pi.on("tool_call", async (event) => {
|
|
953
|
-
if (!state.enabled) return;
|
|
1032
|
+
if (!state.enabled || !workflowMutex.isOwner(workflowOwner)) return;
|
|
954
1033
|
if (event.toolName === "update_plan") {
|
|
955
1034
|
return {
|
|
956
1035
|
block: true,
|
|
@@ -990,16 +1069,12 @@ Blocked command: ${blocked}`
|
|
|
990
1069
|
pi.on("before_agent_start", (event, ctx) => {
|
|
991
1070
|
if (refreshStateBeforeFirstAgentStart) {
|
|
992
1071
|
refreshStateBeforeFirstAgentStart = false;
|
|
993
|
-
restoreState(ctx);
|
|
994
1072
|
implementationRetention.reset();
|
|
1073
|
+
if (!installRestoredState(readRestoredState(ctx), ctx)) return;
|
|
995
1074
|
implementationRetention.restore(state.activeImplementation);
|
|
996
|
-
if (state.enabled) {
|
|
997
|
-
activatePlanModeTools();
|
|
998
|
-
applyPlanThinkingLevel();
|
|
999
|
-
} else deactivatePlanModeQuestionTool();
|
|
1000
1075
|
updateUi(ctx);
|
|
1001
1076
|
}
|
|
1002
|
-
if (!state.enabled) return;
|
|
1077
|
+
if (!state.enabled || !workflowMutex.isOwner(workflowOwner)) return;
|
|
1003
1078
|
if (state.latestPlan || state.awaitingAction) {
|
|
1004
1079
|
readyPresentationIntent = void 0;
|
|
1005
1080
|
state = {
|
|
@@ -1019,7 +1094,7 @@ ${buildPlanModePrompt()}`
|
|
|
1019
1094
|
};
|
|
1020
1095
|
});
|
|
1021
1096
|
pi.on("agent_end", async (event, ctx) => {
|
|
1022
|
-
if (!state.enabled) return;
|
|
1097
|
+
if (!state.enabled || !workflowMutex.isOwner(workflowOwner)) return;
|
|
1023
1098
|
const text = latestAssistantText(event.messages);
|
|
1024
1099
|
const parsedPlan = parseProposedPlan(text);
|
|
1025
1100
|
if (parsedPlan.kind !== "valid") {
|
|
@@ -1061,36 +1136,48 @@ ${intent.plan}`,
|
|
|
1061
1136
|
if (!isStaleExtensionContextError(error)) throw error;
|
|
1062
1137
|
}
|
|
1063
1138
|
});
|
|
1064
|
-
function enterPlanMode(ctx) {
|
|
1139
|
+
function enterPlanMode(ctx, candidate = state) {
|
|
1140
|
+
bindWorkflowSessionIfNeeded(ctx);
|
|
1141
|
+
if (state.enabled) return workflowMutex.isOwner(workflowOwner);
|
|
1142
|
+
const owner = workflowMutex.acquire();
|
|
1143
|
+
if (!owner) return reportWorkflowBusy(ctx);
|
|
1144
|
+
workflowOwner = owner;
|
|
1145
|
+
const previousState = state;
|
|
1146
|
+
const previousToolSnapshot = previousTools;
|
|
1065
1147
|
workflowGeneration += 1;
|
|
1066
|
-
|
|
1067
|
-
|
|
1068
|
-
|
|
1069
|
-
|
|
1070
|
-
|
|
1071
|
-
|
|
1072
|
-
|
|
1073
|
-
|
|
1074
|
-
|
|
1075
|
-
|
|
1076
|
-
|
|
1077
|
-
|
|
1148
|
+
try {
|
|
1149
|
+
previousTools = withoutRequiredPlanModeTools(safeGetActiveTools());
|
|
1150
|
+
state = {
|
|
1151
|
+
...state,
|
|
1152
|
+
enabled: true,
|
|
1153
|
+
awaitingAction: false,
|
|
1154
|
+
savedPlan: void 0,
|
|
1155
|
+
activeImplementation: void 0,
|
|
1156
|
+
selectedToolNames: candidate.selectedToolNames,
|
|
1157
|
+
selectedToolKeys: candidate.selectedToolKeys
|
|
1158
|
+
};
|
|
1159
|
+
activatePlanModeTools();
|
|
1160
|
+
applyPlanThinkingLevel();
|
|
1161
|
+
persistState();
|
|
1162
|
+
updateUi(ctx);
|
|
1163
|
+
return true;
|
|
1164
|
+
} catch (error) {
|
|
1165
|
+
rollbackNewActivation(previousState, previousToolSnapshot, ctx);
|
|
1166
|
+
throw error;
|
|
1167
|
+
}
|
|
1078
1168
|
}
|
|
1079
1169
|
function enterPlanModeWithPrompt(prompt, ctx) {
|
|
1080
1170
|
const previousState = state;
|
|
1171
|
+
const previousOwner = workflowOwner;
|
|
1172
|
+
const previousToolSnapshot = previousTools;
|
|
1081
1173
|
const wasEnabled = state.enabled;
|
|
1082
|
-
enterPlanMode(ctx);
|
|
1174
|
+
if (!enterPlanMode(ctx)) return;
|
|
1083
1175
|
if (!wasEnabled) {
|
|
1084
1176
|
ctx.ui.notify("Plan mode enabled. I will explore and plan, but not modify files.", "info");
|
|
1085
1177
|
}
|
|
1086
1178
|
if (sendPlanModeUserMessage(prompt, ctx)) return;
|
|
1087
|
-
if (
|
|
1088
|
-
|
|
1089
|
-
restoreThinkingLevel();
|
|
1090
|
-
}
|
|
1091
|
-
state = previousState;
|
|
1092
|
-
persistState();
|
|
1093
|
-
updateUi(ctx);
|
|
1179
|
+
if (wasEnabled) return;
|
|
1180
|
+
rollbackNewActivation(previousState, previousToolSnapshot, ctx, previousOwner);
|
|
1094
1181
|
}
|
|
1095
1182
|
function exitPlanMode(ctx) {
|
|
1096
1183
|
workflowGeneration += 1;
|
|
@@ -1113,6 +1200,7 @@ ${intent.plan}`,
|
|
|
1113
1200
|
}
|
|
1114
1201
|
persistState();
|
|
1115
1202
|
updateUi(ctx);
|
|
1203
|
+
if (wasEnabled) releaseWorkflowOwner();
|
|
1116
1204
|
}
|
|
1117
1205
|
function sendPlanModeUserMessage(message, ctx) {
|
|
1118
1206
|
try {
|
|
@@ -1151,7 +1239,7 @@ ${intent.plan}`,
|
|
|
1151
1239
|
updateUi(ctx);
|
|
1152
1240
|
}
|
|
1153
1241
|
function completedPlanIsCurrent(intent) {
|
|
1154
|
-
return state.enabled && state.awaitingAction && state.latestPlan === intent.plan && state.latestPlanSource === intent.source;
|
|
1242
|
+
return state.enabled && workflowMutex.isOwner(workflowOwner) && state.awaitingAction && state.latestPlan === intent.plan && state.latestPlanSource === intent.source;
|
|
1155
1243
|
}
|
|
1156
1244
|
function readyPresentationIsCurrent(intent) {
|
|
1157
1245
|
return completedPlanIsCurrent(intent) && readyPresentationIntent?.nonce === intent.nonce;
|
|
@@ -1163,8 +1251,9 @@ ${intent.plan}`,
|
|
|
1163
1251
|
return;
|
|
1164
1252
|
}
|
|
1165
1253
|
if (savedPlanBlocksNewWorkflow(ctx, state.savedPlan !== void 0)) return;
|
|
1166
|
-
enterPlanMode(ctx)
|
|
1167
|
-
|
|
1254
|
+
if (enterPlanMode(ctx)) {
|
|
1255
|
+
ctx.ui.notify("Plan mode enabled. I will explore and plan, but not modify files.", "info");
|
|
1256
|
+
}
|
|
1168
1257
|
}
|
|
1169
1258
|
function planModeDisableNotification() {
|
|
1170
1259
|
return state.activeImplementation ? "Active implementation plan cleared." : state.savedPlan ? "Saved plan cleared." : state.latestPlan ? "Plan mode disabled. Proposed plan discarded." : "Plan mode disabled.";
|
|
@@ -1205,6 +1294,7 @@ ${intent.plan}`,
|
|
|
1205
1294
|
state = { ...state, manualThinkingLevel: void 0 };
|
|
1206
1295
|
persistState();
|
|
1207
1296
|
updateUi(ctx);
|
|
1297
|
+
releaseWorkflowOwner();
|
|
1208
1298
|
ctx.ui.notify("Plan saved for later. Plan mode disabled.", "info");
|
|
1209
1299
|
}
|
|
1210
1300
|
async function startFreshImplementation(ctx, menuIsCurrent) {
|
|
@@ -1231,6 +1321,8 @@ ${intent.plan}`,
|
|
|
1231
1321
|
}
|
|
1232
1322
|
workflowGeneration += 1;
|
|
1233
1323
|
const previousState = state;
|
|
1324
|
+
const previousIntent = readyPresentationIntent;
|
|
1325
|
+
const previousToolSnapshot = previousTools;
|
|
1234
1326
|
const wasEnabled = state.enabled;
|
|
1235
1327
|
readyPresentationIntent = void 0;
|
|
1236
1328
|
state = {
|
|
@@ -1258,16 +1350,18 @@ ${intent.plan}`,
|
|
|
1258
1350
|
updateUi(ctx);
|
|
1259
1351
|
const sent = sendPlanModeUserMessage(formatImplementationHandoff(plan), ctx);
|
|
1260
1352
|
if (!sent) {
|
|
1261
|
-
|
|
1262
|
-
|
|
1263
|
-
|
|
1264
|
-
|
|
1265
|
-
|
|
1353
|
+
state = previousState;
|
|
1354
|
+
readyPresentationIntent = previousIntent;
|
|
1355
|
+
if (wasEnabled) {
|
|
1356
|
+
previousTools = previousToolSnapshot;
|
|
1357
|
+
applyPlanModeTools();
|
|
1266
1358
|
applyPlanThinkingLevel();
|
|
1267
1359
|
}
|
|
1268
1360
|
persistState();
|
|
1269
1361
|
updateUi(ctx);
|
|
1362
|
+
return;
|
|
1270
1363
|
}
|
|
1364
|
+
if (wasEnabled) releaseWorkflowOwner();
|
|
1271
1365
|
}
|
|
1272
1366
|
function clearActiveImplementation(id, ctx) {
|
|
1273
1367
|
if (state.activeImplementation?.id !== id) return false;
|
|
@@ -1303,18 +1397,19 @@ ${intent.plan}`,
|
|
|
1303
1397
|
...lifecycle,
|
|
1304
1398
|
start: (signal) => {
|
|
1305
1399
|
if (signal.aborted || !lifecycle.isCurrent()) return;
|
|
1306
|
-
enterPlanMode(ctx)
|
|
1307
|
-
|
|
1400
|
+
if (enterPlanMode(ctx)) {
|
|
1401
|
+
ctx.ui.notify(
|
|
1402
|
+
"Plan mode enabled. I will explore and plan, but not modify files.",
|
|
1403
|
+
"info"
|
|
1404
|
+
);
|
|
1405
|
+
}
|
|
1308
1406
|
},
|
|
1309
1407
|
startWithTools: (names, signal) => {
|
|
1310
1408
|
if (signal.aborted || !lifecycle.isCurrent()) return;
|
|
1311
|
-
|
|
1312
|
-
|
|
1313
|
-
|
|
1314
|
-
|
|
1315
|
-
};
|
|
1316
|
-
enterPlanMode(ctx);
|
|
1317
|
-
ctx.ui.notify("Plan mode enabled with the selected tools.", "info");
|
|
1409
|
+
const selectedToolNames = filterAvailableSelectedToolNames(names, tools);
|
|
1410
|
+
if (enterPlanMode(ctx, { selectedToolNames, selectedToolKeys: void 0 })) {
|
|
1411
|
+
ctx.ui.notify("Plan mode enabled with the selected tools.", "info");
|
|
1412
|
+
}
|
|
1318
1413
|
},
|
|
1319
1414
|
settings: (signal) => showSettings(ctx, signal, lifecycle.isCurrent)
|
|
1320
1415
|
});
|
|
@@ -1337,8 +1432,12 @@ ${intent.plan}`,
|
|
|
1337
1432
|
exportPlan: (path, signal) => planExports.export(path, ctx, signal, lifecycle.isCurrent),
|
|
1338
1433
|
settings: (signal) => showSettings(ctx, signal, lifecycle.isCurrent),
|
|
1339
1434
|
startNew: () => {
|
|
1340
|
-
enterPlanMode(ctx)
|
|
1341
|
-
|
|
1435
|
+
if (enterPlanMode(ctx)) {
|
|
1436
|
+
ctx.ui.notify(
|
|
1437
|
+
"Plan mode enabled. I will explore and plan, but not modify files.",
|
|
1438
|
+
"info"
|
|
1439
|
+
);
|
|
1440
|
+
}
|
|
1342
1441
|
},
|
|
1343
1442
|
clear: () => {
|
|
1344
1443
|
exitPlanMode(ctx);
|
|
@@ -1367,10 +1466,11 @@ ${intent.plan}`,
|
|
|
1367
1466
|
function captureMenuLifecycle() {
|
|
1368
1467
|
const sessionGeneration = menuGeneration;
|
|
1369
1468
|
const planWorkflowGeneration = workflowGeneration;
|
|
1469
|
+
const owner = workflowOwner;
|
|
1370
1470
|
const controller = menuController;
|
|
1371
1471
|
return {
|
|
1372
1472
|
signal: controller.signal,
|
|
1373
|
-
isCurrent: () => sessionGeneration === menuGeneration && planWorkflowGeneration === workflowGeneration && !controller.signal.aborted
|
|
1473
|
+
isCurrent: () => sessionGeneration === menuGeneration && planWorkflowGeneration === workflowGeneration && !controller.signal.aborted && (!state.enabled || workflowMutex.isOwner(owner))
|
|
1374
1474
|
};
|
|
1375
1475
|
}
|
|
1376
1476
|
function activatePlanModeTools() {
|
|
@@ -1468,8 +1568,108 @@ ${intent.plan}`,
|
|
|
1468
1568
|
return DEFAULT_TOOLS;
|
|
1469
1569
|
}
|
|
1470
1570
|
}
|
|
1471
|
-
function
|
|
1472
|
-
|
|
1571
|
+
function readRestoredState(ctx) {
|
|
1572
|
+
return restorePlanModeState(ctx.sessionManager.getBranch(), STATE_ENTRY_TYPE);
|
|
1573
|
+
}
|
|
1574
|
+
function installRestoredState(candidate, ctx) {
|
|
1575
|
+
const previousState = state;
|
|
1576
|
+
const previousToolSnapshot = previousTools;
|
|
1577
|
+
const previousOwner = workflowOwner;
|
|
1578
|
+
const wasEnabled = state.enabled;
|
|
1579
|
+
if (candidate.enabled && !workflowMutex.isOwner(workflowOwner)) {
|
|
1580
|
+
const owner = workflowMutex.acquire();
|
|
1581
|
+
if (!owner) {
|
|
1582
|
+
state = { enabled: false, awaitingAction: false };
|
|
1583
|
+
previousTools = void 0;
|
|
1584
|
+
reportRestoredWorkflowBusy(ctx);
|
|
1585
|
+
return false;
|
|
1586
|
+
}
|
|
1587
|
+
workflowOwner = owner;
|
|
1588
|
+
}
|
|
1589
|
+
try {
|
|
1590
|
+
if (wasEnabled && !candidate.enabled) {
|
|
1591
|
+
readyPresentationIntent = void 0;
|
|
1592
|
+
restoreTools();
|
|
1593
|
+
restoreThinkingLevel();
|
|
1594
|
+
}
|
|
1595
|
+
state = candidate;
|
|
1596
|
+
if (state.enabled) {
|
|
1597
|
+
if (!wasEnabled) previousTools = withoutRequiredPlanModeTools(safeGetActiveTools());
|
|
1598
|
+
activatePlanModeTools();
|
|
1599
|
+
applyPlanThinkingLevel();
|
|
1600
|
+
} else {
|
|
1601
|
+
deactivatePlanModeQuestionTool();
|
|
1602
|
+
if (wasEnabled) releaseWorkflowOwner();
|
|
1603
|
+
}
|
|
1604
|
+
return true;
|
|
1605
|
+
} catch (error) {
|
|
1606
|
+
try {
|
|
1607
|
+
if (!wasEnabled && state.enabled) {
|
|
1608
|
+
try {
|
|
1609
|
+
restoreTools();
|
|
1610
|
+
} finally {
|
|
1611
|
+
restoreThinkingLevel();
|
|
1612
|
+
}
|
|
1613
|
+
}
|
|
1614
|
+
} finally {
|
|
1615
|
+
state = previousState;
|
|
1616
|
+
previousTools = previousToolSnapshot;
|
|
1617
|
+
if (workflowOwner !== previousOwner) {
|
|
1618
|
+
workflowMutex.release(workflowOwner);
|
|
1619
|
+
workflowOwner = previousOwner;
|
|
1620
|
+
}
|
|
1621
|
+
}
|
|
1622
|
+
throw error;
|
|
1623
|
+
}
|
|
1624
|
+
}
|
|
1625
|
+
function rollbackNewActivation(previousState, previousToolSnapshot, ctx, previousOwner) {
|
|
1626
|
+
const activatedOwner = workflowOwner;
|
|
1627
|
+
readyPresentationIntent = void 0;
|
|
1628
|
+
try {
|
|
1629
|
+
if (state.enabled) {
|
|
1630
|
+
try {
|
|
1631
|
+
restoreTools();
|
|
1632
|
+
} finally {
|
|
1633
|
+
restoreThinkingLevel();
|
|
1634
|
+
}
|
|
1635
|
+
}
|
|
1636
|
+
} finally {
|
|
1637
|
+
state = previousState;
|
|
1638
|
+
previousTools = previousToolSnapshot;
|
|
1639
|
+
try {
|
|
1640
|
+
persistState();
|
|
1641
|
+
updateUi(ctx);
|
|
1642
|
+
} finally {
|
|
1643
|
+
if (activatedOwner !== previousOwner) {
|
|
1644
|
+
workflowMutex.release(activatedOwner);
|
|
1645
|
+
workflowOwner = previousOwner;
|
|
1646
|
+
}
|
|
1647
|
+
}
|
|
1648
|
+
}
|
|
1649
|
+
}
|
|
1650
|
+
function bindWorkflowSessionIfNeeded(ctx) {
|
|
1651
|
+
if (currentSession === ctx.sessionManager) return;
|
|
1652
|
+
currentSession = ctx.sessionManager;
|
|
1653
|
+
workflowOwner = void 0;
|
|
1654
|
+
workflowMutex.bindSession(ctx.sessionManager);
|
|
1655
|
+
}
|
|
1656
|
+
function releaseWorkflowOwner() {
|
|
1657
|
+
const owner = workflowOwner;
|
|
1658
|
+
workflowMutex.release(owner);
|
|
1659
|
+
if (!workflowMutex.isOwner(owner)) workflowOwner = void 0;
|
|
1660
|
+
}
|
|
1661
|
+
function reportWorkflowBusy(ctx) {
|
|
1662
|
+
const message = "Another workflow is active in this session. End it before starting Plan mode.";
|
|
1663
|
+
if (!ctx.hasUI) throw new Error(message);
|
|
1664
|
+
ctx.ui.notify(message, "warning");
|
|
1665
|
+
return false;
|
|
1666
|
+
}
|
|
1667
|
+
function reportRestoredWorkflowBusy(ctx) {
|
|
1668
|
+
if (!ctx.hasUI) return;
|
|
1669
|
+
ctx.ui.notify(
|
|
1670
|
+
"Plan mode was not restored because another workflow is active in this session. Reload or start Plan mode after it ends.",
|
|
1671
|
+
"warning"
|
|
1672
|
+
);
|
|
1473
1673
|
}
|
|
1474
1674
|
function updateUi(ctx) {
|
|
1475
1675
|
updatePlanModeUi(ctx, state, formatToolSummary);
|