@cmetech/otto 1.3.1 → 1.3.3

package/src/resources/extensions/otto/commands/release-notes/_data.ts

@@ -33,13 +33,37 @@ export interface ReleaseNotesManifest {
 
 export const RELEASE_NOTES_MANIFEST: ReleaseNotesManifest = {
 	truncated: false,
-	total: 17,
+	total: 19,
 	oldestBundled: '1.0.0',
-	newestBundled: '1.3.1',
+	newestBundled: '1.3.3',
 	historyUrl: 'https://github.com/cmetech/otto-cli/blob/main/CHANGELOG.md',
 };
 
 export const RELEASE_NOTES: ReleaseNote[] = [
+	{
+		version: '1.3.3',
+		date: '2026-06-08',
+		headline: 'Maintenance patch rolling up six upstream-ported fixes that landed on `main` since 1.3.2: TUI rendering on JetBrains terminals, pattern-resolution basedir, project-root artifact placement when running inside worktrees, verification-pause diagnostics, per-PID crash-log isolation, and Ollama context-window trust.',
+		fixed: [
+			'**JetBrains terminal capabilities.** TUI rendering now provides the correct capability set when running under JetBrains\' embedded terminal (`packages/pi-tui`), eliminating layout glitches reported on IntelliJ / WebStorm / GoLand. Closes #31 (ported via PR #77).',
+			'**Pattern basedir resolution.** Pattern lookups now resolve against the correct base directory, restoring expected matching behavior for relative glob patterns. Closes #53 (ported via PR #74).',
+			'**Project root artifacts in worktrees.** Workflow runs invoked from a `git worktree` now project root-level artifacts (lockfile, configs, generated files) into the worktree itself instead of leaking into the primary checkout. Closes #90 (PR #370).',
+			'**Verification pause message shows failing check.** When a workflow pauses after an execution step, the message now surfaces *which* check failed instead of a generic pause string, dramatically shortening the debug loop. Closes #99 (PR #371).',
+			'**Crash logs append to single per-PID file.** Crash diagnostics now append to one file per process rather than fragmenting across multiple files, making post-mortem inspection coherent. Closes #343 (PR #374).',
+			'**Ollama `/api/show` context + `num_ctx` sync.** The Ollama integration now trusts the model\'s reported context window from `/api/show`, keeps `num_ctx` in lockstep, and corrects `KNOWN_MODELS` drift — preventing silent truncation when a model\'s real context exceeds the hard-coded table. Closes #345 (PR #375).',
+		],
+		notes: [
+			'Internal: upstream-swarm orchestrator skill + autonomy hardening (PRs #75, #76, #78, #79, #80, #81, #82) landed in this window but are tooling-only and have no runtime impact for end users.',
+		],
+	},
+	{
+		version: '1.3.2',
+		date: '2026-06-04',
+		headline: 'Windows-TUI hotfix on top of 1.3.1: launching `otto` no longer paints three stacked welcome banners on Windows. The CLI rendered correctly all along — it just looked broken because cursor-relative differential updates drifted out of alignment.',
+		fixed: [
+			'**Stacked TUI frames on Windows launch.** `otto` on Windows (PowerShell inside Windows Terminal) painted the welcome banner three times in scrollback instead of updating one frame in place. Root cause traced to `packages/pi-tui/src/tui.ts`: the differential render path uses *relative* cursor movement (`\\x1b[N A/B`) which depends on `hardwareCursorRow` matching the actual terminal cursor row. The welcome screen\'s full-width yellow rule (`\'─\'.repeat(termWidth)` at `src/welcome-screen.ts:192`) is the canonical auto-wrap edge case; Windows ConPTY\'s cursor-state after writing exactly `termWidth` chars differs from xterm\'s "pending wrap" semantic, so each render drifts the tracked cursor by one row. After ~3 async-driven re-renders during cold-start (workflow\'s `session_start` handler has 5+ `await` boundaries, each potentially scheduling a render), drift compounds and subsequent updates write to wrong rows — the previous frame stays visible. Two pi-tui changes resolve it: (1) re-enable DEC 2026 synchronized output on Windows — modern Windows Terminal supports it and the prior `platform !== "win32"` guard predated that; (2) force `fullRender(true)` (absolute-positioned clear + repaint) for all non-first renders on Windows, bypassing the cursor-relative differential path entirely. Trade-off: tiny additional write traffic per render, hidden by synchronized output. Opt-outs: `PI_DISABLE_SYNC_OUTPUT=1` and `PI_DISABLE_WIN32_FULL_REDRAW=1` for terminals that mis-handle either change.',
+		],
+	},
 	{
 		version: '1.3.1',
 		date: '2026-06-04',

package/src/resources/extensions/workflow/auto-verification.ts

@@ -600,6 +600,7 @@ export async function runPostUnitVerification(
     // ── Post-execution checks (run after main verification passes for execute-task units) ──
     let postExecChecks: PostExecutionCheckJSON[] | undefined;
     let postExecBlockingFailure = false;
+    let postExecFailureSummary: string | null = null;
 
     if (result.passed && mid && sid && tid) {
       // Check preferences — respect enhanced_verification and enhanced_verification_post
@@ -696,6 +697,13 @@ export async function runPostUnitVerification(
               const blockingCount = postExecResult.checks.filter(
                 (c) => !c.passed && c.blocking
               ).length;
+              const firstBlockingFailure = postExecResult.checks.find(
+                (c) => !c.passed && c.blocking
+              );
+              if (firstBlockingFailure) {
+                postExecFailureSummary =
+                  `[${firstBlockingFailure.category}] ${firstBlockingFailure.target}: ${firstBlockingFailure.message}`;
+              }
               ctx.ui.notify(
                 `Post-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found`,
                 "error"
@@ -810,12 +818,13 @@ export async function runPostUnitVerification(
       s.verificationRetryCount.delete(retryKey);
       s.verificationRetryFailureHashes.delete(retryKey);
       s.pendingVerificationRetry = null;
+      const failureDetail = postExecFailureSummary ?? "unknown post-execution check failure";
       ctx.ui.notify(
-        `Post-execution checks failed — cross-task consistency issue detected, pausing for human review`,
+        `Post-execution checks failed (${failureDetail}) — pausing for human review`,
         "error",
       );
       await pauseAuto(ctx, pi, {
-        message: "Post-execution checks failed: cross-task consistency issue detected.",
+        message: `Post-execution checks failed: ${failureDetail}.`,
         category: "unknown",
       });
       return "pause";

package/src/resources/extensions/workflow/bootstrap/crash-log.ts

@@ -1,5 +1,5 @@
 /**
- * crash-log.ts — Write crash diagnostics to ~/.otto/crash/<timestamp>.log
+ * crash-log.ts — Write crash diagnostics to ~/.otto/crash/pid-<pid>.log
  *
  * Zero cross-dependencies: only uses Node.js built-ins so it can be imported
  * safely from uncaughtException / unhandledRejection handlers and from tests
@@ -11,15 +11,14 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 
 /**
- * Write a crash log to ~/.otto/crash/<timestamp>.log (or $OTTO_HOME/crash/).
+ * Write a crash log to ~/.otto/crash/pid-<pid>.log (or $OTTO_HOME/crash/).
  * Never throws — must be safe to call from any error handler.
  */
 export function writeCrashLog(err: Error, source: string): void {
   try {
     const crashDir = join((process.env.OTTO_HOME ?? process.env.OTTO_HOME) ?? join(homedir(), ".otto"), "crash");
     mkdirSync(crashDir, { recursive: true });
-    const ts = new Date().toISOString().replace(/[:.]/g, "-");
-    const logPath = join(crashDir, `${ts}.log`);
+    const logPath = join(crashDir, `pid-${process.pid}.log`);
     const lines = [
       `[otto] ${source}: ${err.message}`,
       `timestamp: ${new Date().toISOString()}`,

package/src/resources/extensions/workflow/tests/crash-handler-secondary.test.ts

@@ -49,6 +49,28 @@ describe('register-extension crash handler secondary fixes (#3348)', () => {
     }
   });
 
+  test('writeCrashLog appends repeated crashes from one process to a single file', async () => {
+    const tmpHome = join(tmpdir(), `otto-crash-test-${randomUUID()}`);
+    const origHome = process.env.OTTO_HOME;
+    process.env.OTTO_HOME = tmpHome;
+    try {
+      const { writeCrashLog } = await import('../bootstrap/crash-log.ts');
+      writeCrashLog(new Error('first crash'), 'uncaughtException');
+      writeCrashLog(new Error('second crash'), 'unhandledRejection');
+
+      const crashDir = join(tmpHome, 'crash');
+      const logs = readdirSync(crashDir).filter((f) => f.endsWith('.log'));
+      assert.equal(logs.length, 1, 'repeated writes in one process should share one crash log');
+
+      const content = readFileSync(join(crashDir, logs[0]), 'utf-8');
+      assert.ok(content.includes('first crash'), 'log should contain first error message');
+      assert.ok(content.includes('second crash'), 'log should contain second error message');
+    } finally {
+      process.env.OTTO_HOME = origHome;
+      rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
   test('_gsdRejectionGuard is registered for unhandledRejection', () => {
     installEpipeGuard();
     const listener = process.listeners("unhandledRejection").find((candidate) =>

package/src/resources/extensions/workflow/tests/post-exec-retry-bypass.test.ts

@@ -359,13 +359,8 @@ describe("Post-execution blocking failure retry bypass", () => {
     assert.ok(messages.some((m: string) => m.includes("Verification failed") && m.includes("auto-fix attempt 1/2")));
   });
 
-  test("post-exec failure notification mentions cross-task consistency", async () => {
-    // This test verifies that the notification for post-exec failures includes
-    // the appropriate message about cross-task consistency issues.
-    // The actual post-exec failure would require specific file/output state
-    // that's harder to set up in a unit test, but we can verify the code path exists.
-    
-    createBasicTask();
+  test("post-exec failure notification includes failing check details", async () => {
+    createPostExecFailureTask();
     writePreferences({
       enhanced_verification: true,
       enhanced_verification_post: true,
@@ -381,9 +376,27 @@ describe("Post-execution blocking failure retry bypass", () => {
     const vctx: VerificationContext = { s, ctx, pi };
     const result = await runPostUnitVerification(vctx, pauseAutoMock);
 
-    // The verification should pass with our simple "echo pass" task
-    // This test mainly confirms the wiring is correct
-    assert.equal(result, "continue");
+    assert.equal(result, "pause");
+    assert.equal(pauseAutoMock.mock.callCount(), 1);
+    const notifyMessages = ctx.ui.notify.mock.calls.map((c: { arguments: unknown[] }) =>
+      String(c.arguments[0])
+    );
+    assert.ok(
+      notifyMessages.some(
+        (m: string) =>
+          m.includes("Post-execution checks failed ([import] src/broken.ts:1") &&
+          m.includes("pausing for human review")
+      )
+    );
+
+    const pauseCallArgs = (pauseAutoMock.mock.calls[0]?.arguments as unknown as unknown[])?.[2] as
+      | { message?: string }
+      | undefined;
+    assert.ok(
+      pauseCallArgs?.message?.includes(
+        "Post-execution checks failed: [import] src/broken.ts:1"
+      )
+    );
   });
 
   test("uok gate runner persists post-execution gate failures when enabled", async () => {

package/src/resources/extensions/workflow/tests/worktree-state-projection.test.ts

@@ -2,7 +2,7 @@
 // File Purpose: Worktree State Projection Module — typed-Interface contract tests for projectRootToWorktree (ADR-016).
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
@@ -60,6 +60,46 @@ test("projectRootToWorktree is idempotent — repeated calls do not throw", () =
   }
 });
 
+test("projectRootToWorktree forwards root PROJECT.md into isolated worktrees", () => {
+  const { dir, cleanup } = makeProjectRoot();
+  try {
+    const worktree = join(dir, ".otto/workflow/worktrees/M001");
+    mkdirSync(join(dir, ".otto/workflow/milestones/M001"), { recursive: true });
+    mkdirSync(join(worktree, ".otto/workflow"), { recursive: true });
+
+    const projectContent = [
+      "# Project",
+      "",
+      "## Milestone Sequence",
+      "",
+      "- [ ] M001: Foundation — Establish the runnable slice.",
+      "",
+    ].join("\n");
+    writeFileSync(join(dir, ".otto/workflow/PROJECT.md"), projectContent);
+    writeFileSync(join(dir, ".otto/workflow/REQUIREMENTS.md"), "# Requirements\n");
+    writeFileSync(
+      join(dir, ".otto/workflow/milestones/M001/M001-ROADMAP.md"),
+      "# M001\n",
+    );
+
+    const workspace = createWorkspace(worktree);
+    const scope = scopeMilestone(workspace, "M001");
+    const projection = new WorktreeStateProjection();
+
+    projection.projectRootToWorktree(scope);
+
+    const projectedProject = join(worktree, ".otto/workflow/PROJECT.md");
+    assert.ok(existsSync(projectedProject), "PROJECT.md is available to worktree-bound units");
+    assert.equal(readFileSync(projectedProject, "utf-8"), projectContent);
+    assert.ok(
+      existsSync(join(worktree, ".otto/workflow/milestones/M001/M001-ROADMAP.md")),
+      "milestone artifacts still project into the worktree",
+    );
+  } finally {
+    cleanup();
+  }
+});
+
 // ─── projectWorktreeToRoot — Module contract ────────────────────────────────
 
 test("projectWorktreeToRoot exists and accepts a MilestoneScope", () => {

package/src/resources/extensions/workflow/worktree-state-projection.ts

@@ -172,6 +172,35 @@ const ROOT_DIAGNOSTIC_FILES = [
   "metrics.json",
 ] as const;
 
+/**
+ * Root-level .otto/workflow/ projections copied from project root into worktrees for
+ * compatibility reads. Project root remains authoritative; copy-back still
+ * excludes these markdown projections.
+ */
+const ROOT_FORWARD_PROJECTION_FILES = [
+  "DECISIONS.md",
+  "REQUIREMENTS.md",
+  "PROJECT.md",
+  "KNOWLEDGE.md",
+  "OVERRIDES.md",
+  "QUEUE.md",
+  "completed-units.json",
+  "metrics.json",
+  "mcp.json",
+] as const;
+
+function syncRootProjectionFilesToWorktree(prGsd: string, wtGsd: string): void {
+  mkdirSync(wtGsd, { recursive: true });
+
+  for (const file of ROOT_FORWARD_PROJECTION_FILES) {
+    const src = join(prGsd, file);
+    const dst = join(wtGsd, file);
+    if (!existsSync(src) || existsSync(dst)) continue;
+
+    safeCopy(src, dst, { force: false });
+  }
+}
+
 // ─── Implementation cores ────────────────────────────────────────────────
 //
 // The `_*Impl` exports take raw paths so the deprecated path-string
@@ -204,6 +233,10 @@ export function _projectRootToWorktreeImpl(
   // Compare realpaths and skip when they resolve to the same physical path (#2184).
   if (isSamePath(prGsd, wtGsd)) return;
 
+  // Root PROJECT/REQUIREMENTS/DECISIONS projections must be readable from a
+  // worktree-bound unit; the project root remains authoritative.
+  syncRootProjectionFilesToWorktree(prGsd, wtGsd);
+
   // Copy milestone directory from project root to worktree — additive only.
   // force:false prevents cpSync from overwriting existing worktree files.
   // Without this, worktree-local files (e.g. VALIDATION.md written