Enhance editor features, improve performance, and fix bugs

.github/workflows/ci.yml

@@ -0,0 +1,15 @@
+name: CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  test:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run tests
+        run: make test

.gitignore

@@ -87,7 +87,23 @@ dist/
 /.claude/
 /.vibecrafted/
 /agents
-*.md
-!AGENTS.md
 /.junie
 *.txt
+*.log
+# Broad on purpose: internal docs (specs, plans, agent prompts) sync between
+# machines over Tailscale + rsync, NOT through git/GitHub. Keep all markdown out
+# except the named governance/root files below.
+*.md
+!README.md
+!CODE_OF_CONDUCT.md
+!CHANGELOG.md
+!VERSION
+!CONTRIBUTING.md
+!SECURITY.md
+!AGENTS.md
+/tmp
+/dist
+/docs/superpowers
+*.backup
+/docs/workforce
+/.claude

Makefile

@@ -50,10 +50,33 @@ run: build  ## Build + launch app (debug, no .app bundle)
 run-release: release-local  ## Build + launch signed .app (no notarize)
 	@open "$(APP_BUNDLE)"
 
+.PHONY: install-app
+install-app: release-local  ## Build signed .app + swap the production bundle in /Applications
+	@printf "$(C_CYAN)[install]$(C_RESET) quitting running Pensieve — a live process + bundle swap = SIGKILL (code signature invalid)\n"
+	@osascript -e 'tell application id "io.vetcoders.pensieve" to quit' >/dev/null 2>&1 || true
+	@pkill -x Pensieve >/dev/null 2>&1 || true
+	@sleep 0.6
+	@printf "$(C_CYAN)[install]$(C_RESET) swapping /Applications/Pensieve.app\n"
+	@rm -rf "/Applications/Pensieve.app"
+	@ditto "$(APP_BUNDLE)" "/Applications/Pensieve.app"
+	@printf "$(C_CYAN)[install]$(C_RESET) relaunching from /Applications\n"
+	@open "/Applications/Pensieve.app"
+	@printf "$(C_GREEN)[ ok ]$(C_RESET) installed $(APP_BUNDLE) → /Applications/Pensieve.app\n"
+
 .PHONY: clean
 clean:  ## Remove .build/ + dist/
 	@printf "$(C_CYAN)[clean]$(C_RESET) removing .build + dist\n"
-	@rm -rf $(BUILD_DIR) $(DIST)
+	@# Rename-aside before delete: a live SourceKit/IDE indexer writing into
+	@# .build/index-build races a plain `rm -rf` (it repopulates a dir mid-delete,
+	@# so rmdir hits ENOTEMPTY). An atomic rename detaches the tree from the path
+	@# the indexer holds, so the delete can't lose that race. Best-effort: never
+	@# abort the gated release if a stray file lingers.
+	@for d in $(BUILD_DIR) $(DIST); do \
+		[ -e "$$d" ] || continue; \
+		trash="$$d.trash.$$$$"; \
+		mv "$$d" "$$trash" 2>/dev/null || trash="$$d"; \
+		rm -rf "$$trash" 2>/dev/null || rm -rf "$$trash" 2>/dev/null || true; \
+	done
 	@printf "$(C_GREEN)[ ok ]$(C_RESET) cleaned\n"
 
 .PHONY: clean-deep
@@ -81,12 +104,12 @@ lint:  ## Required format check; fails if swift-format is missing
 		printf "$(C_YELLOW)[missing]$(C_RESET) swift-format is required for lint/release gates (brew install swift-format)\n"; \
 		exit 1; \
 	fi
-	@cd $(PKG_DIR) && swift-format lint --recursive Sources/ Tests/
+	@cd $(PKG_DIR) && swift-format lint $$(find Sources Tests -name '*.swift' ! -path 'Sources/Pensieve/VistaBridge/qube_ffi.swift' -print)
 
 .PHONY: format
 format:  ## Apply swift-format in-place when installed (best-effort helper)
 	@command -v swift-format >/dev/null 2>&1 \
-		&& cd $(PKG_DIR) && swift-format format --in-place --recursive Sources/ Tests/ \
+		&& cd $(PKG_DIR) && swift-format format --in-place $$(find Sources Tests -name '*.swift' ! -path 'Sources/Pensieve/VistaBridge/qube_ffi.swift' -print) \
 		|| printf "$(C_YELLOW)[skip]$(C_RESET) swift-format not installed (brew install swift-format)\n"
 
 .PHONY: gates

Pensieve/Package.swift

@@ -1,8 +1,12 @@
 // swift-tools-version:5.9
 // Pensieve — native macOS markdown editor (file-first, source-first)
 
+import Foundation
 import PackageDescription
 
+let packageRoot = URL(fileURLWithPath: #filePath).deletingLastPathComponent().path
+let qubeFFILibraryPath = "\(packageRoot)/Vendor/qube-ffi/debug"
+
 let package = Package(
     name: "Pensieve",
     platforms: [
@@ -19,6 +23,7 @@ let package = Package(
         .executableTarget(
             name: "Pensieve",
             dependencies: [
+                "qube_ffiFFI",
                 .product(name: "Markdown", package: "swift-markdown"),
                 .product(name: "GRDB", package: "GRDB.swift")
             ],
@@ -27,9 +32,23 @@ let package = Package(
                 .copy("Resources/markdown.css"),
                 .copy("Resources/gfm.css"),
                 .copy("Resources/mermaid.min.js"),
+                .copy("Resources/katex.min.js"),
+                .copy("Resources/katex.inline.min.css"),
                 .copy("Resources/sample.md")
+            ],
+            linkerSettings: [
+                .unsafeFlags([
+                    "-L", qubeFFILibraryPath,
+                    "-lqube_ffi",
+                    "-Xlinker", "-rpath",
+                    "-Xlinker", qubeFFILibraryPath
+                ])
             ]
         ),
+        .systemLibrary(
+            name: "qube_ffiFFI",
+            path: "Sources/qube_ffiFFI"
+        ),
         .testTarget(
             name: "PensieveTests",
             dependencies: [

Pensieve/Sources/Pensieve/App/AgentPromptDispatcher.swift

@@ -0,0 +1,154 @@
+import Foundation
+
+struct AgentDispatchMetadata: Equatable, Sendable {
+  let runID: String?
+  let reportPath: String?
+  let exitCode: Int32
+  let output: String
+
+  var statusLine: String {
+    if exitCode != 0 {
+      return "Dispatch failed (exit \(exitCode))"
+    }
+
+    switch (runID, reportPath) {
+    case (let runID?, let reportPath?):
+      return "Dispatch completed: \(runID) | \(reportPath)"
+    case (let runID?, nil):
+      return "Dispatch completed: \(runID)"
+    case (nil, let reportPath?):
+      return "Dispatch completed: \(reportPath)"
+    case (nil, nil):
+      return "Dispatch completed"
+    }
+  }
+
+  static func parse(output: String, exitCode: Int32) -> AgentDispatchMetadata {
+    AgentDispatchMetadata(
+      runID: firstMatch(
+        in: output,
+        patterns: [
+          #"(?m)^\s*run_id:\s*([^\s]+)\s*$"#,
+          #"(?m)^\s*Run ID:\s*([^\s]+)\s*$"#,
+        ]),
+      reportPath: firstMatch(
+        in: output,
+        patterns: [
+          #"(?m)^\s*Report path:\s*(\S+)\s*$"#,
+          #"(?m)^\s*report_path:\s*(\S+)\s*$"#,
+          // Last-resort fallback: an absolute local path; the lookbehind keeps it from
+          // matching inside URLs ("https://host/reports/x.md") or protocol-relative refs.
+          #"(?<![/:])(/[^/\s][^\s]*/reports/[^\s]+\.md)"#,
+        ]),
+      exitCode: exitCode,
+      output: output
+    )
+  }
+
+  private static func firstMatch(in text: String, patterns: [String]) -> String? {
+    for pattern in patterns {
+      guard let regex = try? NSRegularExpression(pattern: pattern) else { continue }
+      let range = NSRange(text.startIndex..<text.endIndex, in: text)
+      guard let match = regex.firstMatch(in: text, range: range), match.numberOfRanges > 1,
+        let matchRange = Range(match.range(at: 1), in: text)
+      else {
+        continue
+      }
+      return String(text[matchRange])
+    }
+    return nil
+  }
+}
+
+protocol AgentPromptLaunching: Sendable {
+  func dispatch(prompt: String, workingDirectoryURL: URL) throws -> AgentDispatchMetadata
+}
+
+enum AgentPromptLauncherError: LocalizedError {
+  case executableNotFound(searchedPaths: [String])
+
+  var errorDescription: String? {
+    switch self {
+    case .executableNotFound(let searchedPaths):
+      let searched = searchedPaths.joined(separator: ", ")
+      return
+        "vibecrafted executable not found (searched: \(searched)). "
+        + "Set the PENSIEVE_VIBECRAFTED_PATH environment variable to the full path "
+        + "of the vibecrafted script, or install vibecrafted under "
+        + "~/.local/share/vibecrafted/tools/vibecrafted-current/scripts/vibecrafted."
+    }
+  }
+}
+
+final class VibecraftedAgentPromptLauncher: AgentPromptLaunching, @unchecked Sendable {
+  static let executablePathEnvironmentKey = "PENSIEVE_VIBECRAFTED_PATH"
+  static let defaultExecutableRelativePath =
+    ".local/share/vibecrafted/tools/vibecrafted-current/scripts/vibecrafted"
+
+  static func resolveExecutablePath() throws -> String {
+    var candidates: [String] = []
+    if let override = ProcessInfo.processInfo.environment[executablePathEnvironmentKey],
+      !override.isEmpty
+    {
+      candidates.append(override)
+    }
+    candidates.append(
+      FileManager.default.homeDirectoryForCurrentUser
+        .appendingPathComponent(defaultExecutableRelativePath).path)
+
+    for candidate in candidates where FileManager.default.isExecutableFile(atPath: candidate) {
+      return candidate
+    }
+    throw AgentPromptLauncherError.executableNotFound(searchedPaths: candidates)
+  }
+
+  func dispatch(prompt: String, workingDirectoryURL: URL) throws -> AgentDispatchMetadata {
+    let executablePath = try Self.resolveExecutablePath()
+    let process = Process()
+    process.executableURL = URL(fileURLWithPath: executablePath)
+    process.arguments = ["implement", "codex", "--prompt", prompt]
+    process.currentDirectoryURL = workingDirectoryURL
+
+    let stdout = Pipe()
+    let stderr = Pipe()
+    let buffer = ProcessOutputBuffer()
+    process.standardOutput = stdout
+    process.standardError = stderr
+
+    stdout.fileHandleForReading.readabilityHandler = { handle in
+      buffer.append(handle.availableData)
+    }
+    stderr.fileHandleForReading.readabilityHandler = { handle in
+      buffer.append(handle.availableData)
+    }
+
+    try process.run()
+    process.waitUntilExit()
+
+    stdout.fileHandleForReading.readabilityHandler = nil
+    stderr.fileHandleForReading.readabilityHandler = nil
+    buffer.append(stdout.fileHandleForReading.availableData)
+    buffer.append(stderr.fileHandleForReading.availableData)
+
+    return AgentDispatchMetadata.parse(output: buffer.text(), exitCode: process.terminationStatus)
+  }
+}
+
+private final class ProcessOutputBuffer: @unchecked Sendable {
+  private let lock = NSLock()
+  private var data = Data()
+
+  func append(_ next: Data) {
+    guard !next.isEmpty else { return }
+    lock.lock()
+    data.append(next)
+    lock.unlock()
+  }
+
+  func text() -> String {
+    lock.lock()
+    let snapshot = data
+    lock.unlock()
+    return String(data: snapshot, encoding: .utf8) ?? ""
+  }
+}