@selesai/code 0.3.6 → 0.3.8

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/deepseek-v4-flash
+model: tokenin/qwen3.5-397b
 thinking: high
 description: Implementation agent for normal tasks handoffs
 systemPromptMode: replace

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

@@ -1,5 +1,7 @@
 ---
 name: researcher
+model: tokenin/kimi-k2.7-code
+thinking: high
 description: Autonomous web researcher — searches, evaluates, and synthesizes a focused research brief
 tools: read, write, web_explore, intercom
 thinking: medium

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
@@ -594,11 +615,32 @@ 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;
+      // 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) {
+        const eff = await sm.onArtifactMaybe(deps);
+        applyEffect(pi, ctx, config, 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
@@ -608,9 +650,18 @@ export function createWorkflowExtension(
           // calls set `action`. Only fall back for execution calls.
           if (typeof event.input?.action !== "string") {
             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) {
+              let shouldWrite = !(await realFileExists(expectedPath));
+              if (!shouldWrite) {
+                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");
               }

package/dist/extensions/workflow/state-machine.ts

@@ -441,7 +441,9 @@ export class WorkflowStateMachine {
       const sat = await this.artifactSatisfiedFor(this.phase, deps);
       if (!sat.exists) return { kind: "noOp" };
       if (sat.reason) {
-        this.autoArmed = false;
+        // Keep armed: the artifact exists but failed the semantic gate. The
+        // next corrected write/subagent result must be able to advance this
+        // same phase; disarming here leaves the workflow stuck forever.
         const missing = this.config.phaseArtifacts[this.phase]!;
         return { kind: "blocked", phase: this.phase, missing, reason: sat.reason };
       }

package/package.json

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