@selesai/code 0.3.7 → 0.3.9

package/dist/extensions/caveman/index.js

@@ -5,19 +5,7 @@ const { getCavemanInstructions } = require("./caveman-instructions.cjs");
 
 export { getCavemanInstructions };
 
-export function resolveSessionActive(entries, fallback = true) {
-  if (!Array.isArray(entries)) return fallback;
 
-  for (let i = entries.length - 1; i >= 0; i -= 1) {
-    const entry = entries[i];
-    if (entry?.type !== "custom" || entry?.customType !== "caveman-mode") continue;
-
-    const active = entry?.data?.active;
-    if (typeof active === "boolean") return active;
-  }
-
-  return fallback;
-}
 
 export function parseCavemanCommand(text) {
   const normalizedText = String(text || "").trim().toLowerCase();
@@ -93,8 +81,7 @@ export default function cavemanExtension(pi) {
   });
 
   pi.on("session_start", async (_event, ctx) => {
-    const entries = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
-    active = resolveSessionActive(entries, true);
+    active = true; // ponytail: always ON at session start; OFF is current-session-only
     syncStatus(ctx);
     ctx?.ui?.notify?.(`Caveman loaded: ${active ? "ON" : "OFF"}`, "info");
   });

package/dist/extensions/caveman/test/extension.test.js

@@ -80,7 +80,7 @@ test("disabled caveman skips instruction injection", async () => {
   assert.equal(result, undefined);
 });
 
-test("session_start restores latest persisted active flag", async () => {
+test("session_start always ON even if persisted entry is OFF", async () => {
   const { events } = createPiHarness();
   const ctx = createCommandContext({
     sessionManager: {
@@ -93,7 +93,22 @@ test("session_start restores latest persisted active flag", async () => {
   await events.get("session_start")({ reason: "resume" }, ctx);
   const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
 
-  assert.equal(result, undefined); // persisted false -> no injection
+  assert.ok(result.systemPrompt.includes("CAVEMAN MODE ACTIVE"));
+});
+
+test("off then new session_start resets to ON", async () => {
+  const { commands, events } = createPiHarness();
+  const ctx = createCommandContext();
+
+  await events.get("session_start")({ reason: "startup" }, ctx);
+  await commands.get("caveman").handler("off", ctx);
+
+  // Simulate a fresh session_start (new harness = fresh active state)
+  const { events: events2 } = createPiHarness();
+  await events2.get("session_start")({ reason: "new" }, ctx);
+  const result = await events2.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
+
+  assert.ok(result.systemPrompt.includes("CAVEMAN MODE ACTIVE"));
 });
 
 test("'stop caveman' as a whole message deactivates mid-session", async () => {

package/dist/extensions/caveman/test/helpers.test.js

@@ -7,7 +7,6 @@ import {
   getCavemanInstructions,
   isDeactivationCommand,
   parseCavemanCommand,
-  resolveSessionActive,
 } from "../index.js";
 
 test("parseCavemanCommand: bare toggles", () => {
@@ -27,20 +26,7 @@ test("parseCavemanCommand: unknown arg is invalid", () => {
   assert.deepEqual(parseCavemanCommand("banana"), { type: "invalid", reason: "unknown-subcommand", arg: "banana" });
 });
 
-test("resolveSessionActive: latest persisted entry wins", () => {
-  const entries = [
-    { type: "custom", customType: "caveman-mode", data: { active: false } },
-    { type: "custom", customType: "caveman-mode", data: { active: true } },
-  ];
-  assert.equal(resolveSessionActive(entries, true), true);
-});
 
-test("resolveSessionActive: non-array entries fall back", () => {
-  assert.equal(resolveSessionActive(null, true), true);
-  assert.equal(resolveSessionActive(undefined, false), false);
-  assert.equal(resolveSessionActive({}, true), true);
-  assert.equal(resolveSessionActive("nope"), true); // DEFAULT fallback
-});
 
 test("isDeactivationCommand: only the whole message, case-insensitive, trailing punct ok", () => {
   assert.equal(isDeactivationCommand("stop caveman"), true);

package/dist/extensions/pi-subagents/agents/builder.md

@@ -1,6 +1,6 @@
 ---
 name: builder
-model: tokenin/qwen3.5-397b
+model: tokenin/qwen3.6-35b
 thinking: high
 description: Implementation agent for normal tasks handoffs
 systemPromptMode: replace

package/dist/extensions/workflow/adapter.ts

@@ -81,6 +81,27 @@ function textFromToolResultContent(content: unknown): string | undefined {
   return joined || undefined;
 }
 
+function validatorForPhaseArtifact(config: WorkflowConfig, phase: Phase) {
+  const phaseValidator = config.artifactValidators?.[phase];
+  if (phaseValidator) return phaseValidator;
+  const file = config.phaseArtifacts[phase];
+  if (!file) return undefined;
+  const isTerminal = config.phases[config.phases.length - 1] === phase;
+  if (!isTerminal || !config.closeArtifacts.includes(file)) return undefined;
+  return config.closeValidators?.[file];
+}
+
+function shouldReplaceInvalidArtifact(
+  config: WorkflowConfig,
+  phase: Phase,
+  currentContent: string,
+  fallbackContent: string,
+): boolean {
+  const validator = validatorForPhaseArtifact(config, phase);
+  if (!validator) return false;
+  return !validator(currentContent).ok && validator(fallbackContent).ok;
+}
+
 // ponytail: rewrite the subagent tool input so the child writes its output
 // directly to ${artifactDir}/${file} as an absolute path. Absolute paths pass
 // through resolveSingleOutputPath verbatim, so injectOutputPathSystemPrompt
@@ -154,6 +175,8 @@ interface WorkflowController {
   // Ceiling: not persisted across session restart — a restart re-runs the
   // loop from round 0. Acceptable for a prototype workflow.
   loopState?: LoopState;
+  seenToolCallIds: Set<string>;
+  lastBlockedKey?: string;
 }
 
 // ponytail: Plan 3 — loop orchestration state. The parent model does not
@@ -317,6 +340,30 @@ function applyEffect(
   }
 }
 
+function blockedKeyFor(eff: WorkflowEffect): string | undefined {
+  if (eff.kind !== "blocked") return undefined;
+  return `${eff.phase}:${eff.missing}:${eff.reason ?? ""}`;
+}
+
+function applyControllerEffect(
+  controller: WorkflowController,
+  ctx: ExtensionContext,
+  eff: WorkflowEffect,
+): void {
+  const blockedKey = blockedKeyFor(eff);
+  if (blockedKey) {
+    if (controller.lastBlockedKey === blockedKey) return;
+    controller.lastBlockedKey = blockedKey;
+  } else if (eff.kind !== "noOp") {
+    controller.lastBlockedKey = undefined;
+  }
+  applyEffect(controller.pi, ctx, controller.config, eff);
+}
+
+function isSubagentManagementAction(input: Record<string, unknown> | undefined): boolean {
+  return typeof input?.action === "string";
+}
+
 function registerSharedArtifactWriter(pi: ExtensionAPI): void {
   if (registry.writerRegisteredFor.has(pi)) return;
   registry.writerRegisteredFor.add(pi);
@@ -353,7 +400,7 @@ function registerSharedArtifactWriter(pi: ExtensionAPI): void {
       await mkdir(snap.artifactDir, { recursive: true });
       await writeFile(path, params.content, "utf8");
       const eff = await controller.sm.onArtifactMaybe(controller.deps);
-      applyEffect(pi, ctx, controller.config, eff);
+      applyControllerEffect(controller, ctx, eff);
       if (eff.kind === "blocked" && eff.reason) {
         return {
           content: [{ type: "text", text: `Wrote ${path}, but it is not approved: ${eff.reason}. Re-write it via write_workflow_artifact to add the required marker.` }],
@@ -389,7 +436,7 @@ export function createWorkflowExtension(
       },
     ];
     const sm = new WorkflowStateMachine({ ...config, skipRules });
-    const controller: WorkflowController = { pi, config, sm, deps };
+    const controller: WorkflowController = { pi, config, sm, deps, seenToolCallIds: new Set() };
     registry.controllers.push(controller);
     registerSharedArtifactWriter(pi);
     const { start, end } = options.toolNames;
@@ -419,7 +466,11 @@ export function createWorkflowExtension(
           };
         }
         const eff = await sm.start(params.goal, deps);
-        applyEffect(pi, ctx, config, eff);
+        if (eff.kind === "started") {
+          controller.seenToolCallIds.clear();
+          controller.lastBlockedKey = undefined;
+        }
+        applyControllerEffect(controller, ctx, eff);
         if (eff.kind === "alreadyActive") {
           return {
             content: [
@@ -459,7 +510,11 @@ export function createWorkflowExtension(
       parameters: Type.Object({}),
       async execute(_id, _params, _signal, _onUpdate, ctx) {
         const eff = await sm.end(deps);
-        applyEffect(pi, ctx, config, eff);
+        applyControllerEffect(controller, ctx, eff);
+        if (eff.kind === "closed") {
+          controller.seenToolCallIds.clear();
+          controller.lastBlockedKey = undefined;
+        }
         switch (eff.kind) {
           case "closed":
             return {
@@ -554,7 +609,7 @@ export function createWorkflowExtension(
       if (tool !== "subagent" && tool !== "write" && tool !== "edit") return;
       const snap = sm.snapshot;
       if (!snap.active) return;
-      if (tool === "subagent" && typeof event.input?.action === "string") return;
+      if (tool === "subagent" && isSubagentManagementAction(event.input)) return;
       const file = config.phaseArtifacts[snap.phase];
       if (tool === "write" || tool === "edit") {
         return {
@@ -594,11 +649,37 @@ export function createWorkflowExtension(
     // ── tool_result: auto-advance after subagent/bash artifacts. ──
     pi.on("tool_result", async (event: any, ctx: ExtensionContext) => {
       if (event.toolName !== "bash" && event.toolName !== "subagent") return;
+      if (sm.snapshot.active && typeof event.toolCallId === "string") {
+        if (controller.seenToolCallIds.has(event.toolCallId)) return;
+        controller.seenToolCallIds.add(event.toolCallId);
+      }
+      // ponytail: a failed phase-owner tool used to leave the workflow quiet
+      // until the user manually typed /prototype or /quick continue. Re-check
+      // first (in case the tool wrote the artifact before failing), then if
+      // nothing advanced, re-queue the current phase prompt automatically.
+      if (event.isError && sm.snapshot.active) {
+        if (event.toolName === "subagent" && isSubagentManagementAction(event.input)) return;
+        const eff = await sm.onArtifactMaybe(deps);
+        applyControllerEffect(controller, ctx, eff);
+        if (eff.kind === "noOp") {
+          const retry = sm.continueCurrent();
+          continueAgent(
+            pi,
+            ctx,
+            `The previous ${event.toolName} call failed during the ${retry.phase} phase. Stay in this phase and try again.\n\n${retry.prompt}`,
+          );
+        }
+        if (sm.snapshot.phase !== "loop") {
+          controller.loopState = undefined;
+        }
+        return;
+      }
       // ponytail: if a subagent returned text but did not write the expected
       // artifact (common with dumb/local models), save the returned text as
       // the artifact so the workflow can still advance.
       if (event.toolName === "subagent" && sm.snapshot.active && SUBAGENT_FALLBACK_PHASES.has(sm.snapshot.phase)) {
-        const file = config.phaseArtifacts[sm.snapshot.phase];
+        const phase = sm.snapshot.phase;
+        const file = config.phaseArtifacts[phase];
         if (file) {
           // ponytail: management actions (list/get/models/doctor/status/...)
           // return text but are NOT the architect/recapper/... execution
@@ -606,11 +687,23 @@ export function createWorkflowExtension(
           // on agent-listing output (the `subagent list` result is plain
           // text). Execution calls set `agent`/`chain`/`tasks`; management
           // calls set `action`. Only fall back for execution calls.
-          if (typeof event.input?.action !== "string") {
+          if (!isSubagentManagementAction(event.input)) {
             const expectedPath = resolve(sm.snapshot.artifactDir, file);
-            if (!(await realFileExists(expectedPath))) {
-              const text = textFromToolResultContent(event.content);
-              if (text) {
+            const text = textFromToolResultContent(event.content);
+            if (text) {
+              const validator = validatorForPhaseArtifact(config, phase);
+              let shouldWrite = false;
+              if (!(await realFileExists(expectedPath))) {
+                shouldWrite = !validator || validator(text).ok;
+              } else {
+                try {
+                  const current = await readFile(expectedPath, "utf8");
+                  shouldWrite = shouldReplaceInvalidArtifact(config, phase, current, text);
+                } catch {
+                  shouldWrite = false;
+                }
+              }
+              if (shouldWrite) {
                 await mkdir(sm.snapshot.artifactDir, { recursive: true });
                 await writeFile(expectedPath, text, "utf8");
               }
@@ -675,7 +768,7 @@ or
         // onArtifactMaybe (a no-op unless loop-complete.md exists).
       }
       const eff = await sm.onArtifactMaybe(deps);
-      applyEffect(pi, ctx, config, eff);
+      applyControllerEffect(controller, ctx, eff);
       // Clear loop state once we have left the loop phase (advanced to audit).
       if (sm.snapshot.phase !== "loop") {
         controller.loopState = undefined;
@@ -708,7 +801,7 @@ or
           if (choice === undefined) return;
           if (choice.startsWith("Continue")) {
             const eff = sm.continueCurrent();
-            applyEffect(pi, ctx, config, eff);
+            applyControllerEffect(controller, ctx, eff);
             if (eff.kind === "advanced" && eff.prompt) {
               // continueCurrent already applied footer+entry; send the prompt.
               continueAgent(pi, ctx, eff.prompt);
@@ -745,7 +838,11 @@ or
           return;
         }
         const eff = await sm.start(args, deps);
-        applyEffect(pi, ctx, config, eff);
+        if (eff.kind === "started") {
+          controller.seenToolCallIds.clear();
+          controller.lastBlockedKey = undefined;
+        }
+        applyControllerEffect(controller, ctx, eff);
       },
     });
   };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@selesai/code",
-	"version": "0.3.7",
+	"version": "0.3.9",
 	"description": "Selesai coding agent",
 	"type": "module",
 	"piConfig": {