@naxodev/apnea 0.1.0 → 0.2.1

package/extension/workflows/setup.ts

@@ -1,11 +1,7 @@
 import * as path from "node:path"
+import * as os from "node:os"
 import { Effect, Result } from "effect"
-import { supportsFloating } from "../domain/herdr.ts"
-import {
-  globalConfigPath,
-  packageRoot,
-  projectConfigPath,
-} from "../domain/paths.ts"
+import { globalConfigPath, projectConfigPath } from "../domain/paths.ts"
 import {
   buildGlobalConfig,
   detectionNotes,
@@ -14,9 +10,8 @@ import {
 } from "../domain/setup.ts"
 import { ConfigError, type AppError } from "../errors.ts"
 import { ok, type ToolResult } from "../result.ts"
-import { decodeGlobalConfig } from "../schema/config.ts"
+import { decodeGlobalConfig, decodeProjectConfig } from "../schema/config.ts"
 import { FileSystem } from "../services/file-system.ts"
-import { Herdr } from "../services/herdr.ts"
 
 export type SetupParams = {
   /** Write .apnea/config.json role bindings in cwd */
@@ -76,83 +71,10 @@ export type SetupDeps = {
   onPath: (bin: string) => boolean
   /** Prepare host-specific role resources, or return null when none are needed. */
   materializeRoleAgentDir: () => string | null
-}
-
-export type ProvisionResult = {
-  copied: string | null // dest dir, or null when skipped
-  linked: boolean // true only when we ran `herdr plugin link` OK
-  already_linked: boolean
-  notes: string[]
+  /** Trusted account home. Production uses node:os.homedir(). */
+  trustedHome?: () => string
 }
 
-/**
- * Copy the package's herdr-plugin into a stable config-local path and, when
- * herdr is new enough and the plugin isn't already linked, run
- * `herdr plugin link`. Never fails — every branch is a note.
- */
-export const provisionHerdrPlugin = (opts: {
-  srcDir: string // packageRoot()/herdr-plugin
-  destDir: string // dirname(globalConfigPath())/herdr-plugin
-  version: [number, number, number] | null // herdr.version
-}): Effect.Effect<ProvisionResult, never, FileSystem | Herdr> =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem
-    const herdr = yield* Herdr
-    const notes: string[] = []
-
-    const srcExists = yield* fs.exists(opts.srcDir)
-    if (!srcExists) {
-      notes.push("herdr-plugin missing from package — reinstall @naxodev/apnea")
-      return { copied: null, linked: false, already_linked: false, notes }
-    }
-
-    yield* fs.copyDir(opts.srcDir, opts.destDir)
-    const runTask = path.join(opts.destDir, "scripts", "run-task.sh")
-    if (yield* fs.exists(runTask)) {
-      yield* fs.chmod(runTask, 0o755)
-    }
-
-    if (!supportsFloating(opts.version)) {
-      const ver =
-        opts.version == null
-          ? "unknown"
-          : `${opts.version[0]}.${opts.version[1]}.${opts.version[2]}`
-      notes.push(
-        `herdr ${ver} < 0.7.4 — floating panes unavailable; run \`herdr update\`, then re-run /apnea setup`,
-      )
-      return {
-        copied: opts.destDir,
-        linked: false,
-        already_linked: false,
-        notes,
-      }
-    }
-
-    if (yield* herdr.hasApneaPlugin) {
-      return {
-        copied: opts.destDir,
-        linked: false,
-        already_linked: true,
-        notes,
-      }
-    }
-
-    const linkResult = yield* herdr.linkPlugin(opts.destDir)
-    if (!linkResult.ok) {
-      notes.push(
-        `herdr plugin link failed: ${linkResult.raw.trim() || "(no output)"}`,
-      )
-      return {
-        copied: opts.destDir,
-        linked: false,
-        already_linked: false,
-        notes,
-      }
-    }
-
-    return { copied: opts.destDir, linked: true, already_linked: false, notes }
-  })
-
 /**
  * Deterministic Apnea setup: detect binaries, write global profiles
  * (and optional project role bindings). Never writes cmd into project config.
@@ -161,28 +83,9 @@ export const setupWorkflow = (
   params: SetupParams,
   root: string,
   deps: SetupDeps,
-): Effect.Effect<ToolResult, AppError, FileSystem | Herdr> =>
+): Effect.Effect<ToolResult, AppError, FileSystem> =>
   Effect.gen(function* () {
     const fs = yield* FileSystem
-    const herdr = yield* Herdr
-
-    const readJsonSafe = (
-      filePath: string,
-    ): Effect.Effect<Record<string, unknown>> =>
-      Effect.gen(function* () {
-        const present = yield* fs.exists(filePath)
-        if (!present) return {}
-        const text = yield* fs.readFile(filePath)
-        try {
-          const v = JSON.parse(text)
-          if (v && typeof v === "object" && !Array.isArray(v)) {
-            return v as Record<string, unknown>
-          }
-          return {}
-        } catch {
-          return {}
-        }
-      })
 
     const has: Detected = {
       pi: deps.onPath("pi"),
@@ -200,27 +103,64 @@ export const setupWorkflow = (
       })
     }
 
-    const gPath = globalConfigPath()
-    yield* fs.mkdir(path.dirname(gPath), { recursive: true })
+    const trustedHome = deps.trustedHome?.() ?? os.homedir()
+    const gPath = globalConfigPath(trustedHome)
 
-    const prev = yield* readJsonSafe(gPath)
     const force = params.force === true
+    let replacedMalformedGlobal = false
+    let prev: Record<string, unknown> = {}
+    if (yield* fs.exists(gPath)) {
+      const text = yield* fs.readTrustedGlobalFile(trustedHome, gPath)
+      try {
+        const parsed: unknown = JSON.parse(text)
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+          throw new Error("global config must be a JSON object")
+        }
+        prev = parsed as Record<string, unknown>
+      } catch (error) {
+        if (!force) {
+          return yield* new ConfigError({
+            message: `existing global config is malformed; refusing to replace it without --force: ${error instanceof Error ? error.message : String(error)}`,
+            path: gPath,
+          })
+        }
+        replacedMalformedGlobal = true
+      }
+    }
     const globalConfig = buildGlobalConfig({ has, prev, force })
 
     const serialized = `${JSON.stringify(globalConfig, null, 2)}\n`
-    yield* fs.writeFile(gPath, serialized)
 
     let projectPath: string | null = null
     if (params.project) {
       const pPath = projectConfigPath(root)
+      if (yield* fs.projectPathExists(root, pPath)) {
+        const text = yield* fs.readProjectFile(root, pPath)
+        let parsed: unknown
+        try {
+          parsed = JSON.parse(text)
+        } catch (error) {
+          return yield* new ConfigError({
+            message: `invalid JSON at ${pPath}: ${error instanceof Error ? error.message : String(error)}`,
+            path: pPath,
+          })
+        }
+        const decoded = decodeProjectConfig(parsed)
+        if (Result.isFailure(decoded)) return yield* decoded.failure
+      }
+      projectPath = pPath
+    }
+
+    yield* fs.writeTrustedGlobalFile(trustedHome, gPath, serialized)
+
+    if (projectPath) {
       // project: roles only — never cmd
       const projectCfg = { roles: pickRoles(has) }
       yield* fs.writeProjectFile(
         root,
-        pPath,
+        projectPath,
         `${JSON.stringify(projectCfg, null, 2)}\n`,
       )
-      projectPath = pPath
     }
 
     const missing = detectionNotes(has)
@@ -241,32 +181,17 @@ export const setupWorkflow = (
       )
     }
 
-    let herdrPlugin: ProvisionResult | null = null
-    let herdrVer: string | null = null
-    if (has.herdr) {
-      const version = yield* herdr.version
-      herdrVer =
-        version == null ? null : `${version[0]}.${version[1]}.${version[2]}`
-      herdrPlugin = yield* provisionHerdrPlugin({
-        srcDir: path.join(packageRoot(), "herdr-plugin"),
-        destDir: path.join(path.dirname(globalConfigPath()), "herdr-plugin"),
-        version,
-      })
-      missing.push(...herdrPlugin.notes)
-    }
-
     let agentsMdPath: string | null = null
     if (params.agents_md) {
       const target = path.join(root, "AGENTS.md")
-      const present = yield* fs.exists(target)
-      const existing = present ? yield* fs.readFile(target) : null
-      yield* fs.writeFile(target, mergeAgentsMd(existing))
+      const present = yield* fs.projectPathExists(root, target)
+      const existing = present ? yield* fs.readProjectFile(root, target) : null
+      yield* fs.writeProjectFile(root, target, mergeAgentsMd(existing))
       agentsMdPath = target
     }
 
-    // A failed decode after writing is a note, not a failure — a user with a
-    // malformed pre-existing config must still get a written config and an
-    // actionable note, never a hard refusal where today there is none.
+    // Generated defaults can still inherit malformed profile or role shapes
+    // from valid JSON. Report those separately from JSON parse refusals.
     const decoded = decodeGlobalConfig(globalConfig)
     if (Result.isFailure(decoded)) {
       missing.push(
@@ -286,16 +211,11 @@ export const setupWorkflow = (
     if (params.agents_md) {
       data.agents_md = agentsMdPath
     }
-    if (has.herdr) {
-      data.herdr_version = herdrVer
-      data.herdr_plugin = herdrPlugin
-        ? {
-            copied: herdrPlugin.copied,
-            linked: herdrPlugin.linked,
-            already_linked: herdrPlugin.already_linked,
-          }
-        : null
-    }
-
-    return ok(`wrote global config ${gPath}`, data)
+    if (replacedMalformedGlobal) data.replaced_malformed_global = true
+    return ok(
+      replacedMalformedGlobal
+        ? `replaced malformed global config ${gPath}`
+        : `wrote global config ${gPath}`,
+      data,
+    )
   })

package/extension/workflows/start.ts

@@ -47,7 +47,7 @@ export const startWorkflow = (
       let pendingStatus: string = "none"
       if (pending) {
         const absPath = pending.startsWith("/") ? pending : `${root}/${pending}`
-        const present = yield* fs.exists(absPath)
+        const present = yield* fs.projectPathExists(root, absPath)
         pendingStatus = present ? "artifact_exists" : "artifact_missing"
       }
       return ok(
@@ -59,7 +59,7 @@ export const startWorkflow = (
             pendingStatus === "artifact_exists"
               ? "call workflow_wait to ingest pending artifact"
               : pendingStatus === "artifact_missing"
-                ? "offer re-dispatch same round via dispatch_role"
+                ? "offer same-round dispatch_role redeliver=true after proving the prior delivery is dead"
                 : "inspect workflow_status and continue legal next step",
         },
         nextAfter(existing.step),
@@ -100,7 +100,7 @@ export const startWorkflow = (
     }
 
     const state: RunState = {
-      version: 1,
+      version: 2,
       slug,
       step: "planning",
       phase_index: 1,
@@ -112,9 +112,9 @@ export const startWorkflow = (
       last_error: null,
       pending_artifact: null,
       pending_role: null,
+      pending_delivery: null,
       pending_pane_id: null,
       pending_pane_label: null,
-      pending_floating_exit: null,
       pending_started_at: null,
       pending_deadline_ms: null,
       pending_nudged_at: null,
@@ -125,7 +125,8 @@ export const startWorkflow = (
       reviewer_tree_fingerprint: null,
       current_phase_package: null,
       current_code_review: null,
-      phase_package_rework: false,
+      required_rework: null,
+      pending_commit: null,
     }
     // The literal above assigns the ladder's fields; this re-asserts them
     // through the shared helper so a rung added there cannot be missed here.

package/extension/workflows/status.ts

@@ -1,6 +1,6 @@
 import { Effect, Result } from "effect"
 import { LEGAL_TOOLS, nextAfter } from "../domain/state-machine.ts"
-import type { StateCorrupt } from "../errors.ts"
+import type { AppError } from "../errors.ts"
 import { ok, type ToolResult } from "../result.ts"
 import { Config } from "../services/config.ts"
 import { RunStore } from "../services/run-store.ts"
@@ -12,7 +12,7 @@ import { Vcs } from "../services/vcs.ts"
  */
 export const statusWorkflow = (
   root: string,
-): Effect.Effect<ToolResult, StateCorrupt, RunStore | Config | Vcs> =>
+): Effect.Effect<ToolResult, AppError, RunStore | Config | Vcs> =>
   Effect.gen(function* () {
     const store = yield* RunStore
     const config = yield* Config