@bybrawe/opencode-loop 0.5.28 → 0.5.29

package/scripts/goal-policy-test.mjs

@@ -0,0 +1,143 @@
+import assert from "node:assert/strict"
+import { createGoalExecutionPolicy } from "../src/source/runtime/goal-policy.js"
+
+function goal(id, overrides = {}) {
+  return {
+    id,
+    name: id,
+    kind: "goal",
+    goalStatus: "active",
+    enabled: true,
+    paused: false,
+    noProgressCount: 0,
+    goalProgress: [],
+    ...overrides,
+  }
+}
+
+assert.throws(() => createGoalExecutionPolicy({}), /runShellCommand/)
+
+function policyHarness(shellResults = []) {
+  const shellCalls = []
+  const toasts = []
+  const logs = []
+  let clock = 1000
+  let shellIndex = 0
+  const policy = createGoalExecutionPolicy({
+    runShellCommand: async (command, directory, timeoutMs) => {
+      shellCalls.push({ command, directory, timeoutMs })
+      return shellResults[shellIndex++] || { code: 0, stdout: "ok", stderr: "" }
+    },
+    dangerousShell: (command) => command.includes("danger"),
+    toast: async (_client, message, level) => { toasts.push({ message, level }) },
+    appendLoopLog: async (directory, line, extra) => { logs.push({ directory, line, extra }) },
+    now: () => ++clock,
+  })
+  return { ...policy, shellCalls, toasts, logs }
+}
+
+{
+  const harness = policyHarness()
+  const before = goal("progress", { noProgressCount: 2 })
+  const after = goal("progress", {
+    noProgressCount: 2,
+    goalProgress: [{ time: "now", summary: "Implemented change" }],
+  })
+  const result = await harness.applyGoalNoProgressGuard("/work", {}, "session", after, before)
+  assert.equal(result.noProgressCount, 0)
+  assert.equal(result.lastProgressAt, 1001)
+  assert.equal(harness.logs.length, 0)
+  assert.equal(harness.toasts.length, 0)
+}
+
+{
+  const harness = policyHarness()
+  const before = goal("stall", { maxNoProgress: 3, noProgressCount: 1 })
+  const current = structuredClone(before)
+  const result = await harness.applyGoalNoProgressGuard("/work", {}, "session", current, before)
+  assert.equal(result.noProgressCount, 2)
+  assert.equal(result.lastNoProgressAt, 1001)
+  assert.equal(result.paused, false)
+  assert.deepEqual(harness.logs.map((item) => item.line), ["goal-no-progress"])
+  assert.equal(harness.toasts.length, 0)
+}
+
+{
+  const harness = policyHarness()
+  const before = goal("pause", { maxNoProgress: 2, noProgressCount: 1 })
+  const current = structuredClone(before)
+  const result = await harness.applyGoalNoProgressGuard("/work", {}, "session", current, before)
+  assert.equal(result.noProgressCount, 2)
+  assert.equal(result.paused, true)
+  assert.equal(result.lastNoProgressAt, 1001)
+  assert.equal(result.goalNoProgressPausedAt, 1002)
+  assert.match(result.goalNoProgressReason, /Paused after 2 turn/)
+  assert.deepEqual(harness.logs.map((item) => item.line), ["goal-no-progress", "goal-no-progress-paused"])
+  assert.deepEqual(harness.toasts.map((item) => item.level), ["warning"])
+}
+
+{
+  const harness = policyHarness()
+  const unchanged = goal("skip", { goalChecks: [] })
+  assert.equal(await harness.runGoalChecks("/work", "session", unchanged, {}), unchanged)
+  assert.equal(harness.shellCalls.length, 0)
+  assert.equal(harness.logs.length, 0)
+}
+
+{
+  const harness = policyHarness()
+  const checked = goal("danger", { safe: true, goalChecks: ["danger command"], failureCount: 0 })
+  const result = await harness.runGoalChecks("/work", "session", checked, {})
+  assert.equal(harness.shellCalls.length, 0)
+  assert.equal(result.lastGoalChecks.length, 1)
+  assert.equal(result.lastGoalChecks[0].code, -1)
+  assert.equal(result.failureCount, 1)
+  assert.match(result.lastVerifyFailure, /Blocked dangerous command in safe mode/)
+  assert.deepEqual(harness.toasts.map((item) => item.level), ["warning"])
+  assert.deepEqual(harness.logs.map((item) => item.line), ["goal-checks"])
+}
+
+{
+  const harness = policyHarness([
+    { code: 0, stdout: "tests passed", stderr: "" },
+    { code: 0, stdout: "types passed", stderr: "" },
+  ])
+  const checked = goal("pass", {
+    safe: true,
+    timeoutMs: 12345,
+    goalChecks: ["npm test", "npm run check"],
+    failureCount: 2,
+    goalCompleteWhenChecksPass: true,
+  })
+  const result = await harness.runGoalChecks("/work", "session", checked, {})
+  assert.deepEqual(harness.shellCalls, [
+    { command: "npm test", directory: "/work", timeoutMs: 12345 },
+    { command: "npm run check", directory: "/work", timeoutMs: 12345 },
+  ])
+  assert.equal(result.lastGoalCheckAt, 1001)
+  assert.equal(result.goalChecksPassedAt, 1002)
+  assert.equal(result.goalCompletedAt, 1003)
+  assert.equal(result.failureCount, 0)
+  assert.equal(result.goalStatus, "completed")
+  assert.equal(result.enabled, false)
+  assert.equal(result.paused, true)
+  assert.equal(result.goalSummary, "All configured goal checks passed.")
+  assert.equal(result.goalEvidence, "npm test: exit 0\nnpm run check: exit 0")
+  assert.deepEqual(harness.toasts.map((item) => item.level), ["success"])
+  assert.deepEqual(harness.logs.map((item) => item.line), ["goal-auto-complete", "goal-checks"])
+}
+
+{
+  const harness = policyHarness([{ code: 2, stdout: "", stderr: "compile failed" }])
+  const checked = goal("fail", { goalChecks: ["npm run build"], failureCount: 4 })
+  const result = await harness.runGoalChecks("/work", "session", checked, {})
+  assert.equal(result.lastGoalCheckAt, 1001)
+  assert.equal(result.failureCount, 5)
+  assert.match(result.lastVerifyFailure, /npm run build/)
+  assert.match(result.lastVerifyFailure, /exit=2/)
+  assert.match(result.lastVerifyFailure, /compile failed/)
+  assert.deepEqual(harness.toasts.map((item) => item.level), ["warning"])
+  assert.deepEqual(harness.logs.map((item) => item.line), ["goal-checks"])
+}
+
+console.log("goal policy tests passed")

package/scripts/goal-runtime-test.mjs

@@ -0,0 +1,203 @@
+import assert from "node:assert/strict"
+import { promises as fs } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { readState, writeState } from "../src/source/core/state.js"
+import {
+  buildGoalPrompt,
+  goalReportPath,
+  goalReportText,
+  writeGoalReport,
+  pickGoalJob,
+  parseGoalToolText,
+  hasConcreteGoalEvidence,
+  goalChecksPassed,
+  goalRequiresPassingChecks,
+  goalProgressSnapshot,
+  goalMadeMeaningfulProgress,
+  setGoalComplete,
+  setGoalBlocked,
+  setGoalProgress,
+} from "../src/source/runtime/goal-runtime.js"
+
+const directory = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loop-goal-runtime-"))
+try {
+  await fs.writeFile(path.join(directory, "GOAL.md"), "Ship the tested feature.\n", "utf8")
+  await fs.writeFile(path.join(directory, "EXTRA.md"), "Keep compatibility intact.\n", "utf8")
+  await fs.writeFile(path.join(directory, "CONTEXT.md"), "Current implementation context.\n", "utf8")
+
+  const job = {
+    id: "goal-1",
+    name: "feature",
+    kind: "goal",
+    goalStatus: "active",
+    enabled: true,
+    paused: false,
+    createdAt: new Date(0).toISOString(),
+    action: "Implement the feature safely.",
+    goalFile: "GOAL.md",
+    promptFile: "EXTRA.md",
+    includeFiles: ["CONTEXT.md"],
+    goalAcceptance: ["Tests pass", "Compatibility remains intact"],
+    goalChecks: ["npm test"],
+    verifyCommand: "npm run check",
+    lastGoalChecks: [{ command: "npm test", code: 1 }],
+    lastVerifyFailure: "npm run check failed before the fix",
+    goalCompletionRejectedReason: "configured goal checks have not passed yet",
+    maxNoProgress: 3,
+    noProgressCount: 1,
+    goalProgress: [{ time: "2026-08-14T00:00:00.000Z", summary: "Inspected the failing path", next: "Patch it" }],
+  }
+
+  const prompt = await buildGoalPrompt(directory, job)
+  assert.match(prompt, /EXPERIMENTAL OPENCODE GOAL MODE ITERATION/)
+  assert.ok(prompt.includes(path.resolve(directory)))
+  assert.ok(prompt.includes("Implement the feature safely."))
+  assert.ok(prompt.includes("Ship the tested feature."))
+  assert.ok(prompt.includes("Keep compatibility intact."))
+  assert.ok(prompt.includes("Current implementation context."))
+  assert.ok(prompt.includes("1. Tests pass"))
+  assert.ok(prompt.includes("npm test: exit 1"))
+  assert.ok(prompt.includes("1/3 recent turn(s) without recorded meaningful progress"))
+  assert.ok(prompt.includes("Inspected the failing path"))
+
+  const report = goalReportText({
+    ...job,
+    goalSummary: "Feature implemented.",
+    goalEvidence: "npm test passed and src/index.js was updated",
+    runCount: 4,
+  })
+  assert.ok(report.includes("Status: active"))
+  assert.ok(report.includes("Turns: 4"))
+  assert.ok(report.includes("## Summary"))
+  assert.ok(report.includes("Feature implemented."))
+  assert.ok(report.includes("## Latest checks"))
+  assert.ok(report.includes("npm test: exit 1"))
+
+  await writeGoalReport(directory, "ses-1", { ...job, goalSummary: "Saved report." })
+  const reportPath = goalReportPath(directory, "ses-1", job)
+  assert.equal(await fs.readFile(reportPath, "utf8"), goalReportText({ ...job, goalSummary: "Saved report." }))
+
+  const inactive = { id: "goal-old", name: "old", kind: "goal", goalStatus: "blocked", enabled: false }
+  const active = { id: "goal-current", name: "current", kind: "goal", goalStatus: "active", enabled: true }
+  const state = { jobs: [{ id: "loop", kind: "prompt" }, inactive, active] }
+  assert.equal(pickGoalJob(state), active)
+  assert.equal(pickGoalJob(state, "current"), active)
+  assert.equal(pickGoalJob(state, "1"), inactive)
+  assert.equal(pickGoalJob({ jobs: [] }), undefined)
+
+  assert.deepEqual(parseGoalToolText({ summary: "  done  ", evidence: null }, ["summary", "evidence"]), { summary: "done", evidence: "" })
+  assert.equal(hasConcreteGoalEvidence("done"), false)
+  assert.equal(hasConcreteGoalEvidence("marked complete by /loop-goal-done because I said so"), false)
+  assert.equal(hasConcreteGoalEvidence("npm test passed after updating src/index.js"), true)
+  assert.equal(hasConcreteGoalEvidence("A sufficiently detailed explanation of the concrete implementation and verification work that was completed successfully."), true)
+
+  assert.equal(goalChecksPassed({ lastGoalChecks: [{ code: 0 }, { code: "0" }] }), true)
+  assert.equal(goalChecksPassed({ lastGoalChecks: [{ code: 1 }] }), false)
+  assert.equal(goalChecksPassed({}), false)
+  assert.equal(goalRequiresPassingChecks({ goalChecks: ["npm test"] }), true)
+  assert.equal(goalRequiresPassingChecks({ goalChecks: ["npm test"], goalRequireChecksPass: false }), false)
+
+  const before = { goalStatus: "active", goalProgress: [], goalEvidence: "", lastGoalCheckAt: 0, lastVerifyAt: 0 }
+  assert.equal(goalMadeMeaningfulProgress(before, { ...before }), false)
+  assert.equal(goalMadeMeaningfulProgress(before, { ...before, goalProgress: [{ time: "now", summary: "changed" }] }), true)
+  assert.equal(goalMadeMeaningfulProgress(before, { ...before, goalEvidence: "npm test passed after updating src/index.js" }), true)
+  assert.equal(goalMadeMeaningfulProgress(before, { ...before, lastGoalChecks: [{ code: 0 }], lastGoalCheckAt: 10 }), true)
+  assert.equal(goalMadeMeaningfulProgress(before, { ...before, lastVerifyAt: 10, lastVerifyCode: 0 }), true)
+  assert.equal(goalMadeMeaningfulProgress(before, { ...before, goalStatus: "blocked" }), true)
+
+  assert.deepEqual(goalProgressSnapshot({ goalStatus: "active", goalProgress: [1, 2], goalEvidence: "x", goalChecksPassedAt: 2, lastGoalCheckAt: 3, lastVerifyAt: 4, lastVerifyCode: "0" }), {
+    status: "active",
+    progressCount: 2,
+    evidence: "x",
+    checksPassedAt: 2,
+    lastGoalCheckAt: 3,
+    lastVerifyAt: 4,
+    lastVerifyCode: 0,
+  })
+
+  const lifecycleGoal = (id, overrides = {}) => ({
+    id,
+    name: id,
+    kind: "goal",
+    goalStatus: "active",
+    enabled: true,
+    paused: false,
+    createdAt: new Date(0).toISOString(),
+    action: `Goal ${id}`,
+    goalChecks: ["npm test"],
+    lastGoalChecks: [{ command: "npm test", code: 0 }],
+    noProgressCount: 2,
+    ...overrides,
+  })
+
+  const completeSession = "ses-complete"
+  await writeState(directory, completeSession, { jobs: [lifecycleGoal("complete-goal")] })
+  const rejected = await setGoalComplete(directory, completeSession, { summary: "Too early", evidence: "done" })
+  assert.equal(rejected.ok, false)
+  assert.equal(rejected.rejected, true)
+  let persisted = await readState(directory, completeSession)
+  let persistedJob = persisted.jobs[0]
+  assert.equal(persistedJob.goalStatus, "active")
+  assert.equal(persistedJob.goalCompletionRejectedCount, 1)
+  assert.ok(persistedJob.goalCompletionRejectedAt > 0)
+  assert.match(persistedJob.goalCompletionRejectedReason, /concrete evidence is required/)
+
+  const completed = await setGoalComplete(directory, completeSession, {
+    summary: "Feature completed",
+    evidence: "npm test passed after updating src/index.js",
+  })
+  assert.equal(completed.ok, true)
+  persisted = await readState(directory, completeSession)
+  persistedJob = persisted.jobs[0]
+  assert.equal(persistedJob.goalStatus, "completed")
+  assert.equal(persistedJob.enabled, false)
+  assert.equal(persistedJob.paused, true)
+  assert.equal(persistedJob.goalSummary, "Feature completed")
+  assert.equal(persistedJob.goalEvidence, "npm test passed after updating src/index.js")
+  assert.equal(persistedJob.noProgressCount, 0)
+  assert.ok(persistedJob.goalCompletedAt > 0)
+
+  const progressSession = "ses-progress"
+  await writeState(directory, progressSession, { jobs: [lifecycleGoal("progress-goal")] })
+  const progress = await setGoalProgress(directory, progressSession, {
+    summary: "  Patched runtime  ",
+    next: "  Run tests  ",
+    evidence: "  src/index.js updated and npm test prepared  ",
+  })
+  assert.equal(progress.ok, true)
+  persisted = await readState(directory, progressSession)
+  persistedJob = persisted.jobs[0]
+  assert.equal(persistedJob.goalProgress.length, 1)
+  assert.equal(persistedJob.goalProgress[0].summary, "Patched runtime")
+  assert.equal(persistedJob.goalProgress[0].next, "Run tests")
+  assert.equal(persistedJob.goalProgress[0].evidence, "src/index.js updated and npm test prepared")
+  assert.equal(persistedJob.goalEvidence, "src/index.js updated and npm test prepared")
+  assert.equal(persistedJob.noProgressCount, 0)
+  assert.ok(persistedJob.lastProgressAt > 0)
+
+  const blockedSession = "ses-blocked"
+  await writeState(directory, blockedSession, { jobs: [lifecycleGoal("blocked-goal")] })
+  const blocked = await setGoalBlocked(directory, blockedSession, {
+    reason: "Need credential",
+    needed: "API token",
+    evidence: "npm test cannot reach service",
+  })
+  assert.equal(blocked.ok, true)
+  persisted = await readState(directory, blockedSession)
+  persistedJob = persisted.jobs[0]
+  assert.equal(persistedJob.goalStatus, "blocked")
+  assert.equal(persistedJob.enabled, false)
+  assert.equal(persistedJob.paused, true)
+  assert.equal(persistedJob.goalBlockedReason, "Need credential\nNeeded: API token")
+  assert.equal(persistedJob.goalEvidence, "npm test cannot reach service")
+  assert.ok(persistedJob.goalBlockedAt > 0)
+
+  const missing = await setGoalProgress(directory, "ses-missing", { summary: "nothing" })
+  assert.equal(missing.ok, false)
+  assert.match(missing.message, /No active experimental goal/)
+
+  console.log("goal runtime tests passed")
+} finally {
+  await fs.rm(directory, { recursive: true, force: true })
+}

package/scripts/goal-steering-test.mjs

@@ -0,0 +1,153 @@
+import assert from "node:assert/strict"
+import { createGoalSteeringRuntime } from "../src/source/runtime/goal-steering.js"
+import { guardLoopOwnedUserMessage, loopOwnedUserMessageGuardActive, clearLoopOwnedUserMessageGuard } from "../src/source/opencode/messages.js"
+
+function goal(id = "goal-1") {
+  return {
+    id,
+    name: "goal",
+    kind: "goal",
+    action: "keep working",
+    enabled: true,
+    paused: false,
+    goalStatus: "active",
+  }
+}
+
+function userEvent(sessionID = "ses-steering", messageID = "user-steering") {
+  return {
+    type: "message.updated",
+    properties: {
+      info: { id: messageID, sessionID, role: "user", time: { created: 1000 } },
+    },
+  }
+}
+
+function assistantEvent(sessionID = "ses-steering", parentID = "user-steering") {
+  return {
+    type: "message.updated",
+    properties: {
+      info: { id: "assistant-steering", parentID, sessionID, role: "assistant", time: { created: 1100 } },
+    },
+  }
+}
+
+{
+  const originalGoal = goal()
+  const state = { jobs: [structuredClone(originalGoal)] }
+  let activeRun = { jobId: originalGoal.id, job: structuredClone(originalGoal), startedAt: 900 }
+  let aborts = 0
+  let clears = 0
+  const logs = []
+  const client = { session: { abort: async () => { aborts += 1 } } }
+  const runtime = createGoalSteeringRuntime({
+    getActiveRun: () => activeRun,
+    clearActiveRun: () => { clears += 1; activeRun = undefined },
+    readState: async () => structuredClone(state),
+    appendLoopLog: async (_directory, type, detail) => logs.push({ type, detail }),
+    fireSdk: async (_client, _label, method) => await method(),
+    isLoopOwnedUserMessage: () => false,
+    now: () => 1000,
+  })
+
+  const result = await runtime.handleUserMessage("/workspace", client, { sessionID: "ses-steering", messageID: "user-steering" })
+  assert.equal(result.handled, true)
+  assert.equal(result.preempted, true)
+  assert.equal(aborts, 1, "chat.message steering should abort only the active Goal turn before the new prompt dispatches")
+  assert.equal(clears, 1, "the aborted Goal run must no longer be finalized as a completed loop run")
+  assert.equal(runtime.shouldSuppressIdle("ses-steering"), true, "abort-generated idle must be suppressed while steering is queued")
+  assert.deepEqual(state.jobs[0], originalGoal, "normal steering must not pause or rewrite the Goal contract")
+  assert.equal(logs.at(-1)?.type, "goal-user-steering")
+  assert.equal(logs.at(-1)?.detail?.preempted, true)
+
+  const duplicate = await runtime.handleEvent("/workspace", client, userEvent())
+  assert.equal(duplicate.duplicate, true, "message.updated must not abort a steering message already handled by chat.message")
+  assert.equal(aborts, 1)
+  assert.equal(clears, 1)
+
+  await runtime.handleEvent("/workspace", client, assistantEvent())
+  assert.equal(runtime.shouldSuppressIdle("ses-steering"), false, "matching steering assistant turn should release idle suppression")
+}
+
+{
+  const currentGoal = goal()
+  let aborts = 0
+  const runtime = createGoalSteeringRuntime({
+    getActiveRun: () => undefined,
+    clearActiveRun: () => assert.fail("no active run should be cleared"),
+    readState: async () => ({ jobs: [structuredClone(currentGoal)] }),
+    appendLoopLog: async () => {},
+    fireSdk: async () => { aborts += 1 },
+    isLoopOwnedUserMessage: () => false,
+    now: () => 2000,
+  })
+  const result = await runtime.handleUserMessage("/workspace", { session: { abort: async () => {} } }, { sessionID: "ses-idle", messageID: "user-idle" })
+  assert.equal(result.handled, true)
+  assert.equal(result.preempted, false)
+  assert.equal(aborts, 0, "an idle Goal should let the foreground user turn start normally")
+  assert.equal(runtime.shouldSuppressIdle("ses-idle"), false)
+}
+
+{
+  const currentGoal = goal()
+  const ordinary = { id: "loop-1", kind: "prompt", enabled: true, paused: false }
+  let aborts = 0
+  const runtime = createGoalSteeringRuntime({
+    getActiveRun: () => ({ jobId: ordinary.id, job: ordinary, startedAt: 1 }),
+    clearActiveRun: () => assert.fail("ordinary Loop work must not be preempted by Goal steering logic"),
+    readState: async () => ({ jobs: [structuredClone(currentGoal), ordinary] }),
+    appendLoopLog: async () => {},
+    fireSdk: async () => { aborts += 1 },
+    isLoopOwnedUserMessage: () => false,
+    now: () => 3000,
+  })
+  const result = await runtime.handleUserMessage("/workspace", { session: { abort: async () => {} } }, { sessionID: "ses-ordinary", messageID: "user-ordinary" })
+  assert.equal(result.handled, true)
+  assert.equal(result.preempted, false)
+  assert.equal(aborts, 0)
+}
+
+{
+  let reads = 0
+  const runtime = createGoalSteeringRuntime({
+    getActiveRun: () => undefined,
+    clearActiveRun: () => {},
+    readState: async () => { reads += 1; return { jobs: [goal()] } },
+    appendLoopLog: async () => {},
+    isLoopOwnedUserMessage: () => true,
+  })
+  const result = await runtime.handleUserMessage("/workspace", { session: {} }, { sessionID: "ses-owned", messageID: "owned-message" })
+  assert.equal(result.loopOwned, true)
+  assert.equal(reads, 0, "Loop-owned synthetic user messages must not be mistaken for human steering")
+}
+
+{
+  let clock = 4000
+  const currentGoal = goal()
+  const runtime = createGoalSteeringRuntime({
+    getActiveRun: () => ({ jobId: currentGoal.id, job: currentGoal, startedAt: 1 }),
+    clearActiveRun: () => {},
+    readState: async () => ({ jobs: [structuredClone(currentGoal)] }),
+    appendLoopLog: async () => {},
+    fireSdk: async (_client, _label, method) => await method(),
+    isLoopOwnedUserMessage: () => false,
+    now: () => clock,
+    suppressionMs: 100,
+  })
+  await runtime.handleUserMessage("/workspace", { session: { abort: async () => {} } }, { sessionID: "ses-expire", messageID: "user-expire" })
+  assert.equal(runtime.shouldSuppressIdle("ses-expire"), true)
+  clock += 101
+  assert.equal(runtime.shouldSuppressIdle("ses-expire"), false, "lost steering must not suppress autonomous continuation forever")
+}
+
+{
+  const sessionID = "ses-loop-owned-two-stage"
+  guardLoopOwnedUserMessage(sessionID)
+  assert.equal(loopOwnedUserMessageGuardActive(sessionID), true, "chat.message should recognize a pending synthetic prompt before OpenCode assigns its ID")
+  assert.equal(loopOwnedUserMessageGuardActive(sessionID, "synthetic-user-1"), true, "message.updated should consume the pending guard and bind the real synthetic message ID")
+  assert.equal(loopOwnedUserMessageGuardActive(sessionID, "synthetic-user-1"), true, "the bound synthetic message ID should remain Loop-owned for later duplicate events")
+  clearLoopOwnedUserMessageGuard(sessionID)
+  assert.equal(loopOwnedUserMessageGuardActive(sessionID, "synthetic-user-1"), false)
+}
+
+console.log("Goal steering runtime tests passed")