iterate-plugin 3.6.0 → 3.7.0

package/src/client/session-cache.ts

@@ -0,0 +1,54 @@
+/**
+ * src/client/session-cache.ts — the newest session the session-scoped slots saw.
+ *
+ * Slot scopes in dsh are not uniform: `conversation.input.dock` (dashboard,
+ * observatory) renders inside a session and receives `props.session`, while
+ * `settings.section` renders at ROOT scope on the settings page and gets no
+ * session at all. The settings card nevertheless needs session-derived state —
+ * specifically the config the model echoed back through `iterate_config`, which
+ * is what closes the config write → read-back loop.
+ *
+ * Rather than fake a session for the root slot, the session-scoped slots
+ * publish what the host handed them and root-scoped panels subscribe:
+ *
+ *   session slot renders → noteSession(props.session)
+ *   settings panel       → useSessionSnapshot() (via subscribeSession)
+ *
+ * Design constraints (mirrors `i18n.ts`):
+ *   - **Pure**: no React, no DOM — the store is unit-testable on its own, and
+ *     the React binding lives next to `useLang()` in index.ts.
+ *   - **Identity-compared**: the same session object never notifies twice, so
+ *     a slot that re-renders every frame cannot spin its subscribers.
+ *   - **Never fabricated**: it only ever holds what the host really passed; an
+ *     empty cache reads as "nothing echoed yet", which is the honest state.
+ */
+
+/** Anything host-shaped; the plugins only ever pass it through opaque. */
+export type CachedSession = unknown
+
+let current: CachedSession = null
+
+const listeners = new Set<() => void>()
+
+/**
+ * Publish the session a session-scoped slot was rendered with.
+ * Notifies subscribers only when the identity actually changes.
+ */
+export function noteSession(session: CachedSession): void {
+  if (Object.is(session, current)) return
+  current = session
+  for (const listener of [...listeners]) listener()
+}
+
+/** Last published session (or `null` before any session slot has rendered). */
+export function readSession(): CachedSession {
+  return current
+}
+
+/** Subscribe to session changes; returns the unsubscribe function. */
+export function subscribeSession(listener: () => void): () => void {
+  listeners.add(listener)
+  return () => {
+    listeners.delete(listener)
+  }
+}

package/src/config-loader.ts

@@ -3,6 +3,7 @@ import { homedir } from 'node:os'
 import { basename, dirname, join, resolve, sep } from 'node:path'
 import yaml from 'js-yaml'
 import type { IterateConfig } from './types.ts'
+import { sessionCwdOf } from './working-directory.ts'
 
 /**
  * Load and parse iterate.config.yaml from the project root.
@@ -748,12 +749,17 @@ export function resolveProjectRoot(input?: string, sessionCwd?: string): Project
 /**
  * Thin adapter for tool `execute(args, exec)` bodies: pull the session cwd
  * from the DSH run context and hand it to {@link resolveProjectRoot}.
+ *
+ * The cwd source is the EFFECTIVE session directory (dsh 0.2.1-alpha.2's
+ * `workingDirectory` service when the host provides one, else the immutable
+ * `header.cwd` — see `./working-directory.ts`), so a session whose directory
+ * was switched mid-run still resolves the project it is actually editing.
  */
 export function resolveProjectRootForExec(
   exec: { agent?: { session?: { header?: { cwd?: string } } } } | undefined,
   input?: string,
 ): ProjectRootResult {
-  return resolveProjectRoot(input, exec?.agent?.session?.header?.cwd)
+  return resolveProjectRoot(input, sessionCwdOf(exec))
 }
 
 /**

package/src/file-lock.ts

@@ -151,15 +151,42 @@ export function acquireProjectLock(
     } catch {
       // best-effort
     }
-    let released = false
-    return () => {
-      if (released) return
-      released = true
-      try {
-        unlinkSync(lockPath)
-      } catch {
-        // already gone
-      }
+    return makeLockRelease(lockPath)
+  }
+}
+
+/**
+ * Build the release function for a lock file this process just acquired.
+ *
+ * Advisory locks here are STOLEN when the recorded owner dies or the mtime
+ * goes ancient: the steal unlinks our file and creates a new one stamped with
+ * the STEALER's pid. An unguarded release would then unlink the new holder's
+ * lock — turning our release into a double-release that admits a third process
+ * into a "held" critical section. So the release re-reads the stamp and only
+ * unlinks a file that is still ours (same pid) or unstamped (the shape left
+ * when our own advisory pid write failed, or when the content is not a pid).
+ *
+ * Always callable, idempotent, and never throws.
+ */
+export function makeLockRelease(lockPath: string): () => void {
+  let released = false
+  return () => {
+    if (released) return
+    released = true
+    let raw = ''
+    try {
+      raw = readFileSync(lockPath, 'utf-8').trim()
+    } catch {
+      // Already gone (or unreadable) — nothing of ours left to remove.
+      return
+    }
+    // A stamp naming another pid means the lock was stolen and reassigned:
+    // it is no longer ours to delete.
+    if (raw !== '' && Number(raw) !== process.pid) return
+    try {
+      unlinkSync(lockPath)
+    } catch {
+      // already gone
     }
   }
 }

package/src/index.ts

@@ -45,6 +45,7 @@ import { registerQualityGateTool } from './tools/quality-gate.ts'
 import { registerDefenseEventsTool } from './tools/defense-events.ts'
 import { registerSessionHooks } from './session-hooks.ts'
 import { registerLiveCapture } from './live.ts'
+import { installWorkingDirectoryContext } from './working-directory.ts'
 import { ITERATE_SKILL_PROMPT } from './skill-prompt.ts'
 
 export const name = 'iterate-plugin'
@@ -58,6 +59,12 @@ export function apply(ctx: Context): void {
   //    running with NO `tools/pre-execute` approval gate — a fail-open hole
   //    created by load order. Registering the gate first means a partial load
   //    can only ever err on the side of MORE gating, never less.
+  //
+  //    The working-directory context is installed first for the same reason:
+  //    every cwd read below (gate policy, live capture, tool project roots)
+  //    must see dsh 0.2.1-alpha.2+ directory switches, and installing it last
+  //    would leave a partially-loaded plugin resolving the wrong workspace.
+  installWorkingDirectoryContext(ctx)
   registerSessionHooks(ctx)
   registerLiveCapture(ctx)
 

package/src/live.ts

@@ -34,6 +34,7 @@ import { join } from 'node:path'
 import type { Context } from '@deepseek-ai/cordis'
 import type { ToolExecution } from '@deepseek-ai/dsh-tools'
 import { loadEffectiveConfig, resolveProjectRoot } from './config-loader.ts'
+import { sessionCwdOf } from './working-directory.ts'
 
 /** Keep at most this many live activity entries. */
 export const LIVE_MAX_ENTRIES = 300
@@ -140,7 +141,7 @@ export function appendLive(projectRoot: string, entry: LiveActivityEntry): Promi
 
 /** Resolve the project root a tool execution belongs to, if any. */
 function projectRootOf(exec: ToolExecution): string | null {
-  const cwd = exec.agent?.session?.header?.cwd
+  const cwd = sessionCwdOf(exec)
   if (!cwd) return null
   const resolved = resolveProjectRoot(undefined, cwd)
   return resolved.ok ? resolved.root : null

package/src/session-hooks.ts

@@ -55,6 +55,7 @@
 
 import { loadEffectiveConfig, resolveProjectRoot } from './config-loader.ts'
 import { decideApproval, isDestructiveIterateTool } from './approval-gate.ts'
+import { sessionCwdOf } from './working-directory.ts'
 import type { Context } from '@deepseek-ai/cordis'
 import type { ToolErrorInfo, ToolExecution, PreToolDecision } from '@deepseek-ai/dsh-tools'
 
@@ -114,7 +115,11 @@ export function gateDecision(exec: ToolExecution): PreToolDecision {
       const p = (args as Record<string, unknown>).path
       if (typeof p === 'string') argPath = p
     }
-    sessionCwd = exec?.agent?.session?.header?.cwd
+    // Effective session directory (see ./working-directory.ts): a session whose
+    // directory was switched via dsh 0.2.1-alpha.2's `working_directory` tool
+    // must have its POLICY read from the workspace it is now in — `header.cwd`
+    // alone would read the original project's approval policy.
+    sessionCwd = sessionCwdOf(exec)
   } catch {
     // hostile/proxied exec — fall through with both undefined (defaults to ask)
   }

package/src/tools/decision-log.ts

@@ -13,6 +13,7 @@ import { join } from 'node:path'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import type { JsonValue } from '@deepseek-ai/dsh-util-values'
 import { resolveProjectRootForExec } from '../config-loader.ts'
+import { makeLockRelease } from '../file-lock.ts'
 import type { DecisionLogEntry } from '../types.ts'
 
 const LOG_DIR = '.iterate'
@@ -124,16 +125,13 @@ export function acquireLogLockChecked(
       continue
     }
     // Owned the lock: stamp the holder pid, then release once on return.
+    // The release is ownership-checked (see `makeLockRelease`): a lock stolen
+    // from this process after its owner went stale must not be unlinked by us.
     try { writeSync(fd, String(process.pid)) } catch { /* pid stamp is advisory */ }
     try { closeSync(fd) } catch { /* best-effort */ }
-    let released = false
     return {
       acquired: true,
-      release: () => {
-        if (released) return
-        released = true
-        try { unlinkSync(lockPath) } catch { /* already gone */ }
-      },
+      release: makeLockRelease(lockPath),
     }
   }
 }

package/src/working-directory.ts

@@ -0,0 +1,126 @@
+/**
+ * src/working-directory.ts — follow dsh's mutable session working directory.
+ *
+ * Upstream history:
+ *   - through dsh 0.2.1-alpha.1 the session's working directory WAS the
+ *     immutable `Session.header.cwd`, so reading `exec.agent.session.header.cwd`
+ *     was authoritative;
+ *   - dsh 0.2.1-alpha.2 added the `working_directory` tool and the
+ *     `WorkingDirectoryService` (`@deepseek-ai/dsh-working-directory`), whose
+ *     contract explicitly states "the immutable Session header retains the
+ *     ORIGINAL project" while `working-directory/change` events record the
+ *     current one. After a model/user switches directories mid-session,
+ *     `header.cwd` is therefore stale BY DESIGN.
+ *
+ * The iterate plugin resolves the project root (where `.iterate/` lives, where
+ * fixes are written, and — critically — which workspace the F8 approval policy
+ * is read from) from the session cwd. Sticking to `header.cwd` on a host that
+ * supports directory switches would silently operate on the wrong project:
+ * reviews would anchor to the original checkout while the model edits files
+ * elsewhere, and a `deny` policy in the active workspace would be read from
+ * the original one.
+ *
+ * So the effective directory is resolved through the host's service when it
+ * exists, and degrades to `header.cwd` otherwise:
+ *   - feature-detected (`ctx.get('workingDirectory')`) — hosts older than
+ *     0.2.1-alpha.2 simply have no such service and keep the old behavior;
+ *   - `service.get(session)` is the service's synchronous, I/O-free read of
+ *     the committed directory, so this stays safe on the approval path;
+ *   - every failure mode (no service, service throws, hostile getters, a
+ *     non-string result) falls back to `header.cwd`, never to `undefined`
+ *     where a header cwd exists.
+ *
+ * The service object is fetched lazily on every call, not once at plugin
+ * apply: dsh may register the service after this plugin loads, and a disposed
+ * context must degrade rather than cache a dead handle.
+ */
+
+/** Minimal structural view of dsh's `WorkingDirectoryService` (0.2.1-alpha.2+). */
+interface WorkingDirectoryServiceLike {
+  get(session: unknown): string
+}
+
+/** Minimal structural view of the cordis context surface this module uses. */
+interface ContextLike {
+  get?(name: string, strict?: boolean): unknown
+}
+
+/** The plugin context, installed once by `apply()`; null on hosts without it. */
+let installedContext: ContextLike | null = null
+
+/** True when `value` looks like a cordis context carrying `ctx.get`. */
+function isContextLike(value: unknown): value is ContextLike {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as ContextLike).get === 'function'
+  )
+}
+
+/**
+ * Install the plugin context used to look up the `workingDirectory` service.
+ * Passing anything without a callable `get` clears the installation (tests and
+ * hosts that load the plugin into a degraded context).
+ */
+export function installWorkingDirectoryContext(ctx: unknown): void {
+  installedContext = isContextLike(ctx) ? ctx : null
+}
+
+/** Forget the installed context (test isolation / unload). */
+export function resetWorkingDirectoryContext(): void {
+  installedContext = null
+}
+
+/**
+ * Read the host's committed working directory for `session`, if the host
+ * provides the service and it answers with a usable absolute path.
+ *
+ * Returns `undefined` for every degradation path so callers keep their
+ * previous `header.cwd` behavior.
+ */
+function serviceWorkingDirectory(session: unknown): string | undefined {
+  if (session === undefined || session === null) return undefined
+  const ctx = installedContext
+  if (!ctx) return undefined
+  try {
+    const service = ctx.get?.('workingDirectory')
+    if (!service || typeof (service as WorkingDirectoryServiceLike).get !== 'function') return undefined
+    const dir = (service as WorkingDirectoryServiceLike).get(session)
+    // A relative or empty directory would move the project root somewhere
+    // unspecified — refuse it and keep the header value instead.
+    if (typeof dir !== 'string' || dir.length === 0) return undefined
+    return dir
+  } catch {
+    // Missing/disposed service, unpublished session, or a throwing getter —
+    // degrade to the historical source rather than failing the tool call.
+    return undefined
+  }
+}
+
+/**
+ * The effective working directory of a session: the host's committed
+ * directory when available, else the immutable session header cwd.
+ *
+ * Returns `undefined` only when neither source yields a usable path.
+ */
+export function effectiveSessionCwd(session: unknown, headerCwd?: string): string | undefined {
+  const fromService = serviceWorkingDirectory(session)
+  if (fromService !== undefined) return fromService
+  return typeof headerCwd === 'string' && headerCwd.length > 0 ? headerCwd : undefined
+}
+
+/**
+ * Extract the effective cwd from a tool execution (`exec.agent.session`),
+ * reading every property defensively: a hostile/proxied exec must degrade to
+ * the fallback path, never throw out of an approval or capture hook.
+ */
+export function sessionCwdOf(exec: unknown): string | undefined {
+  try {
+    const agent = (exec as { agent?: { session?: { header?: { cwd?: unknown } } } } | null | undefined)?.agent
+    const session = agent?.session
+    const headerCwd = typeof agent?.session?.header?.cwd === 'string' ? agent.session.header.cwd : undefined
+    return effectiveSessionCwd(session, headerCwd)
+  } catch {
+    return undefined
+  }
+}