chore(release): sync dev to main for v1.0.37

.github/releases/v1.0.37.md

@@ -0,0 +1,44 @@
+## opencode {VERSION}
+
+{Prerelease/Stable} release from `{branch}` branch. DAG replan topology refresh: equal-count replans now surface a `graphRev` revision that makes the TUI re-fetch superseded node graphs exactly once instead of rendering stale topology.
+
+---
+
+### 🎯 Features
+
+- **DAG replan topology refresh, #469**: an equal-count replan (node count and status distribution unchanged) previously never triggered a TUI node re-fetch, so the inspector and an expanded sidebar kept rendering superseded topology until the next unrelated state change. The existing `workflow.graph_rev` counter is now exposed end to end as `graphRev` (core summary, schema contract, HttpAPI response, regenerated SDK types) and folded into the inspector and sidebar refresh signatures, so a revision-only change triggers exactly one authoritative node re-fetch while no-op summaries stay refetch-free and no polling is added.
+
+---
+
+### ⚙️ CI / Engineering
+
+- `spec_git/policy.yaml` required checks realigned, 29e876ac2c: SpecGit acceptance for dev deliveries now requires the `Typecheck` and `Unit Tests (linux)` checks instead of the `unit-tests`/`e2e-tests` ids, matching the dev gates where E2E does not block.
+- JS SDK regenerated: the generated `DagWorkflowSummary` types carry the new `graphRev` field, and the CI `Check generated SDK` freshness gate passes.
+
+---
+
+### 🧪 Test Summary
+
+- New `packages/tui/test/feature-plugins/dag-panel.test.tsx` regression suite: equal-count replan bumps `graphRev` alone and refetches exactly once; a no-op summary replacement with the same `graphRev` and counts does not refetch.
+- Companion coverage: inspector refetch-once (`dag-inspector.test.tsx`), equal-count replan summary emission (`dag-summary-publisher-behavior.test.ts`), core summary store revision (`dag-store-summaries.test.ts`), and the HttpAPI contract exercise asserting `summary.graphRev`.
+
+```
+typecheck: root 29/29 tasks green
+test:dag-core: pass
+test:httpapi:ci: 230 pass / 0 fail
+focused suites: inspector 29 pass, sidebar/sync 7 pass
+CI @ 29e876ac2c: Typecheck / Unit Tests (linux) / E2E linux+windows / CodeQL all pass
+lint: 4836 warnings (ratchet 4850)
+```
+
+---
+
+### 🔍 Verification
+
+- DAG development workflow `dag_fe5fa90eeff6BrTFcV9rWDOSyK`: final review ACCEPT after R1 fixes, and `specgit finish --json` exited 0 with the PR #469 checklist complete.
+- All 8 GitHub checks on PR #469 green at 29e876ac2c, including E2E on linux (2m38s) and windows (7m19s).
+- Scope honesty: the only feature surface in this range is the DAG summary and TUI refresh signature; no upstream sync content, no dependency changes, and no standalone architecture or refactor entries.
+
+---
+
+**Full changelog:** [`{previous_tag}`...`{current_tag}`](https://github.com/LeXwDeX/OpenCode-GraphAgent/compare/{previous_tag}...{current_tag})

.specgit.yaml

@@ -1,8 +1,8 @@
 version: 1
-delivery: dag-project-discovery
+delivery: shell-silence-guard
 context:
   kind: branch
-  branch: feat/435-dag-project-discovery
+  branch: feat/433-shell-silence-guard
 issues:
-  - 435
-pr: 490
+  - 433
+pr: 491

packages/core/src/dag/store.ts

@@ -75,6 +75,8 @@ export interface WorkflowSummary {
   id: string
   title: string
   status: string
+  /** Topology invalidation token (#468): bumped by replan, so TUI refresh signatures can detect equal-count replans. */
+  graphRev: number
   nodeCount: number
   completedNodes: number
   runningNodes: number
@@ -323,6 +325,7 @@ export const layer = Layer.effect(
           id: wf.id,
           title: wf.title,
           status: wf.status,
+          graphRev: wf.graph_rev,
           ...(counts.get(wf.id) ?? { nodeCount: 0, completedNodes: 0, runningNodes: 0, failedNodes: 0, skippedNodes: 0, queuedNodes: 0 }),
           escalatedNodes: escalatedByWorkflow.get(wf.id) ?? 0,
         }))

packages/core/src/git.ts

@@ -852,6 +852,13 @@ export const layer = Layer.effect(
       })
     })
 
+    // forceRequired must be derived from locale-stable porcelain state only:
+    // git's refusal prose is translated (e.g. zh_CN catalogs) and never matches reliably.
+    const worktreeDirty = Effect.fnUntraced(function* (directory: AbsolutePath) {
+      const status = yield* execute(directory, proc)(["status", "--porcelain"]).pipe(Effect.result)
+      return status._tag === "Success" && status.success.exitCode === 0 && status.success.text.trim() !== ""
+    })
+
     const worktreeRun = Effect.fnUntraced(function* (
       operation: "create" | "remove" | "list",
       repository: Repository,
@@ -872,7 +879,11 @@ export const layer = Layer.effect(
         operation,
         directory: worktreeDirectory,
         message,
-        forceRequired: operation === "remove" && /contains modified or untracked files|is dirty/i.test(message),
+        forceRequired:
+          operation === "remove" &&
+          result.exitCode === 128 &&
+          worktreeDirectory !== undefined &&
+          (yield* worktreeDirty(worktreeDirectory)),
       })
     })
 

packages/core/test/dag-rev-view-legacy.test.ts

@@ -104,6 +104,7 @@ describe("Train A rev-view — legacy rows render unchanged (A-p4 PIN)", () => {
           id: "wf-legacy",
           title: "Legacy",
           status: "running",
+          graphRev: 1,
           nodeCount: 4,
           completedNodes: 2,
           runningNodes: 0,

packages/core/test/dag-store-summaries.test.ts

@@ -94,6 +94,7 @@ describe("DagStore.getWorkflowSummaries (SQL aggregation)", () => {
           id: "wf-mixed",
           title: "Mixed",
           status: "running",
+          graphRev: 1,
           nodeCount: 7,
           completedNodes: 2,
           runningNodes: 1,
@@ -106,6 +107,7 @@ describe("DagStore.getWorkflowSummaries (SQL aggregation)", () => {
           id: "wf-empty",
           title: "Empty",
           status: "running",
+          graphRev: 1,
           nodeCount: 0,
           completedNodes: 0,
           runningNodes: 0,

packages/core/test/filesystem/watcher.test.ts

@@ -225,12 +225,33 @@ describeWatcher("Watcher", () => {
           const branch = `watch-${Math.random().toString(36).slice(2)}`
           yield* ready(directory)
           yield* Effect.promise(() => $`git branch ${branch}`.cwd(directory).quiet())
+          // Contract for an existing HEAD: once the backend stream has seen HEAD, an
+          // update publishes "change" and removal publishes "unlink". The first write
+          // to a pre-existing but stream-unseen HEAD is backend vocabulary (fs-events
+          // may flag ItemCreated, surfacing as "add" on macOS), so it is consumed only
+          // to record HEAD in the stream — its classification is deliberately not
+          // asserted, while the asserted "change" and "unlink" must match exactly.
+          yield* eventuallyUpdate(
+            (event) => event.file === head,
+            () => fs.writeFileString(head, `ref: refs/heads/${branch}\n`),
+          )
+          const renamed = `watch-${Math.random().toString(36).slice(2)}`
+          yield* Effect.promise(() => $`git branch ${renamed}`.cwd(directory).quiet())
           expect(
-            yield* nextUpdate((event) => event.file === head, fs.writeFileString(head, `ref: refs/heads/${branch}\n`)),
+            yield* nextUpdate(
+              (event) => event.file === head && event.event === "change",
+              fs.writeFileString(head, `ref: refs/heads/${renamed}\n`),
+            ),
           ).toEqual({
             file: head,
             event: "change",
           })
+          expect(
+            yield* nextUpdate((event) => event.file === head && event.event === "unlink", fs.remove(head)),
+          ).toEqual({
+            file: head,
+            event: "unlink",
+          })
         }),
       { git: true },
     ),
@@ -247,14 +268,27 @@ describeWatcher("Watcher", () => {
             yield* Effect.addFinalizer(() => Effect.promise(() => fs.rm(actual, { recursive: true, force: true })))
             yield* ready(directory)
             const head = path.join(directory, ".git", "HEAD")
+            const resolved = path.join(actual, "HEAD")
             const branch = `watch-${Math.random().toString(36).slice(2)}`
             yield* Effect.promise(() => $`git branch ${branch}`.cwd(directory).quiet())
+            // Same contract as the direct .git/HEAD case, observed through the symlink:
+            // events carry the realpath of the store, so both the update and the
+            // removal are asserted against actual/HEAD exactly.
+            yield* eventuallyUpdate(
+              (event) => event.file === resolved,
+              () => afs.writeFileString(head, `ref: refs/heads/${branch}\n`),
+            )
+            const renamed = `watch-${Math.random().toString(36).slice(2)}`
+            yield* Effect.promise(() => $`git branch ${renamed}`.cwd(directory).quiet())
             expect(
               yield* nextUpdate(
-                (event) => event.file === path.join(actual, "HEAD"),
-                afs.writeFileString(head, `ref: refs/heads/${branch}\n`),
+                (event) => event.file === resolved && event.event === "change",
+                afs.writeFileString(head, `ref: refs/heads/${renamed}\n`),
               ),
-            ).toEqual({ file: path.join(actual, "HEAD"), event: "change" })
+            ).toEqual({ file: resolved, event: "change" })
+            expect(
+              yield* nextUpdate((event) => event.file === resolved && event.event === "unlink", afs.remove(head)),
+            ).toEqual({ file: resolved, event: "unlink" })
           }),
         {
           git: true,

packages/core/test/project-copy.test.ts

@@ -192,6 +192,44 @@ describe("ProjectCopy", () => {
     }),
   )
 
+  it.live("requires force to remove a git worktree with tracked modifications", () =>
+    Effect.gen(function* () {
+      const input = yield* setup()
+      const copy = yield* ProjectCopy.Service
+      const temp = yield* Effect.promise(() => fs.realpath(path.dirname(input.root.path)))
+      const parent = abs(path.join(temp, path.basename(input.root.path) + "-copy-tracked"))
+      yield* Effect.addFinalizer(() =>
+        Effect.promise(() => fs.rm(parent, { recursive: true, force: true })).pipe(Effect.ignore),
+      )
+      yield* Effect.promise(() => Bun.write(path.join(input.sourceDirectory, "tracked.txt"), "base"))
+      yield* Effect.promise(() => $`git add tracked.txt`.cwd(input.sourceDirectory).quiet())
+      yield* Effect.promise(() => $`git commit -m tracked`.cwd(input.sourceDirectory).quiet())
+      const created = yield* copy.create({
+        projectID: input.projectID,
+        strategy: gitWorktree,
+        sourceDirectory: input.sourceDirectory,
+        directory: parent,
+        name: "copy",
+      })
+      yield* Effect.promise(() => Bun.write(path.join(created.directory, "tracked.txt"), "modified"))
+
+      const error = yield* copy
+        .remove({ projectID: input.projectID, directory: created.directory, force: false })
+        .pipe(Effect.flip)
+
+      expect(error).toBeInstanceOf(Git.WorktreeError)
+      if (error instanceof Git.WorktreeError) {
+        expect(error.operation).toBe("remove")
+        expect(error.forceRequired).toBe(true)
+      }
+      expect(yield* stored(input.projectID)).toContainEqual({ directory: created.directory, strategy: "git_worktree" })
+      expect(yield* Effect.promise(() => Bun.file(path.join(created.directory, "tracked.txt")).exists())).toBe(true)
+
+      yield* copy.remove({ projectID: input.projectID, directory: created.directory, force: true })
+      expect(yield* Effect.promise(() => Bun.file(created.directory).exists())).toBe(false)
+    }),
+  )
+
   it.live("preserves copies whose stored strategy is unavailable", () =>
     Effect.gen(function* () {
       const input = yield* setup()

packages/opencode/src/effect/runtime-flags.ts

@@ -50,6 +50,7 @@ export class Service extends ConfigService.Service<Service>()("@opencode/Runtime
   experimentalIconDiscovery: enabledByExperimental("OPENCODE_EXPERIMENTAL_ICON_DISCOVERY"),
   outputTokenMax: positiveInteger("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"),
   bashDefaultTimeoutMs: positiveInteger("OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS"),
+  bashSilenceWarnMs: positiveInteger("OPENCODE_EXPERIMENTAL_BASH_SILENCE_WARN_MS"),
   experimentalNativeLlm: bool("OPENCODE_EXPERIMENTAL_NATIVE_LLM"),
   experimentalWebSockets: bool("OPENCODE_EXPERIMENTAL_WEBSOCKETS"),
   client: Config.string("OPENCODE_CLIENT").pipe(Config.withDefault("cli")),

packages/opencode/src/server/routes/instance/httpapi/groups/dag.ts

@@ -61,6 +61,8 @@ export const WorkflowSummaryResponse = Schema.Struct({
   id: Schema.String,
   title: Schema.String,
   status: Schema.String,
+  // Topology invalidation token (#468): bumped by replan, so TUI refresh signatures can detect equal-count replans.
+  graphRev: Schema.Number,
   nodeCount: Schema.Number,
   completedNodes: Schema.Number,
   runningNodes: Schema.Number,

packages/opencode/src/server/routes/instance/httpapi/handlers/dag.ts

@@ -124,6 +124,7 @@ export const dagHandlers = HttpApiBuilder.group(InstanceHttpApi, "dag", (handler
         id: s.id,
         title: s.title,
         status: s.status,
+        graphRev: s.graphRev,
         nodeCount: s.nodeCount,
         completedNodes: s.completedNodes,
         runningNodes: s.runningNodes,

packages/opencode/src/tool/shell.ts

@@ -27,6 +27,11 @@ export { Parameters } from "./shell/prompt"
 export const SHELL_ABORT_NOTE =
   "The command was aborted before completion (client interrupt or session cancel). For long-running work, bound it with `timeout <seconds>` and stream progress instead of piping into a silent buffer."
 
+const DEFAULT_SILENCE_WARN_MS = 5 * 60 * 1000
+
+const shellSilenceNote = (ms: number) =>
+  `shell tool emitted an inactivity warning after ${ms} ms without output; the command was left running. If this command is expected to stay silent, pass expectedSilent: true to opt out.`
+
 const MAX_METADATA_LENGTH = 30_000
 const CWD = new Set(["cd", "chdir", "popd", "pushd", "push-location", "set-location"])
 const FILES = new Set([
@@ -352,6 +357,7 @@ export const ShellTool = Tool.define(
     const plugin = yield* Plugin.Service
     const flags = yield* RuntimeFlags.Service
     const defaultTimeoutMs = flags.bashDefaultTimeoutMs ?? 2 * 60 * 1000
+    const silenceWarnMs = flags.bashSilenceWarnMs ?? DEFAULT_SILENCE_WARN_MS
 
     const cygpath = Effect.fn("ShellTool.cygpath")(function* (shell: string, text: string) {
       const lines = yield* spawner
@@ -439,6 +445,7 @@ export const ShellTool = Tool.define(
         cwd: string
         env: NodeJS.ProcessEnv
         timeout: number
+        expectedSilent: boolean
       },
       ctx: Tool.Context,
     ) {
@@ -453,6 +460,9 @@ export const ShellTool = Tool.define(
       let cut = false
       let expired = false
       let aborted = false
+      let lastActivity = Date.now()
+      let silenceWarned = false
+      let silenceWarnings = 0
 
       const closeSink = Effect.fnUntraced(function* () {
         const stream = sink
@@ -492,6 +502,8 @@ export const ShellTool = Tool.define(
 
           const readerFiber = yield* Effect.forkScoped(
             Stream.runForEach(Stream.decodeText(handle.all), (chunk) => {
+              lastActivity = Date.now()
+              silenceWarned = false
               const size = Buffer.byteLength(chunk, "utf-8")
               list.push({ text: chunk, size })
               used += size
@@ -537,6 +549,27 @@ export const ShellTool = Tool.define(
             }),
           )
 
+          // Warn-only silence guard: lives on its own fiber and must never
+          // join the race below — a silence warning may not change exit.kind.
+          if (!input.expectedSilent) {
+            yield* Effect.forkScoped(
+              Effect.forever(
+                Effect.gen(function* () {
+                  const idle = Date.now() - lastActivity
+                  yield* Effect.sleep(`${idle < silenceWarnMs ? silenceWarnMs - idle : silenceWarnMs} millis`)
+                  if (silenceWarned || Date.now() - lastActivity < silenceWarnMs) return
+                  silenceWarned = true
+                  silenceWarnings++
+                  yield* ctx.metadata({
+                    metadata: {
+                      output: last + `\n\n${shellSilenceNote(silenceWarnMs)}`,
+                    },
+                  })
+                }),
+              ),
+            )
+          }
+
           const abort = Effect.callback<void>((resume) => {
             if (ctx.abort.aborted) return resume(Effect.void)
             const handler = () => resume(Effect.void)
@@ -579,6 +612,7 @@ export const ShellTool = Tool.define(
         )
       }
       if (aborted) meta.push(SHELL_ABORT_NOTE)
+      for (let i = 0; i < silenceWarnings; i++) meta.push(shellSilenceNote(silenceWarnMs))
       const raw = list.map((item) => item.text).join("")
       const end = tail(raw, limits.maxLines, limits.maxBytes)
       if (end.cut) cut = true
@@ -614,7 +648,7 @@ export const ShellTool = Tool.define(
         const shell = Shell.acceptable(cfg.shell)
         const name = Shell.name(shell)
         const limits = yield* trunc.limits()
-        const prompt = ShellPrompt.render(name, process.platform, limits, defaultTimeoutMs)
+        const prompt = ShellPrompt.render(name, process.platform, limits, defaultTimeoutMs, silenceWarnMs)
         yield* Effect.logInfo("shell tool using shell", { shell })
 
         return {
@@ -649,6 +683,7 @@ export const ShellTool = Tool.define(
                   cwd,
                   env: yield* shellEnv(ctx, cwd),
                   timeout,
+                  expectedSilent: params.expectedSilent === true,
                 },
                 ctx,
               )