cowork-flow 0.0.19 → 0.0.21

package/template/.opencode/plugins/cowork-flow.js

@@ -0,0 +1,317 @@
+import { createHash } from "node:crypto"
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { dirname, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const DEFAULT_CONTRACT_REGISTRY = {
+  contracts: [
+    {
+      id: "COWORK_ENTRY_CONTRACT_V1",
+      path: ".cowork-flow/spec/entry-contract.md",
+      digest: [
+        "Classify main-session requests before task start, resume, archive, or commit.",
+        "Runtime context, not prompt labels, identifies formal subagent sessions.",
+      ],
+      readWhen: ["before task start/resume/archive", "when prompt and bootstrap text conflict"],
+    },
+    {
+      id: "RUNTIME_CONTEXT_DISPATCH_V2",
+      path: ".cowork-flow/spec/subagent-dispatch.md",
+      digest: [
+        "Formal subagent work is keyed by cowork_runtime_context_id.",
+        "Explicit shim bind records bound_context_key before formal output is accepted.",
+      ],
+      readWhen: ["before formal subagent dispatch", "when checking subagent health"],
+    },
+  ],
+}
+
+const pluginRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..")
+
+function asStringList(value) {
+  if (!Array.isArray(value)) {
+    return []
+  }
+  return value.filter((item) => typeof item === "string" && item.trim())
+}
+
+function inputCwd(input) {
+  for (const value of [
+    input?.cwd,
+    input?.session?.cwd,
+    input?.context?.cwd,
+    input?.workspace?.cwd,
+  ]) {
+    if (typeof value === "string" && value.trim()) {
+      return value
+    }
+  }
+  return null
+}
+
+function findRepoRoot(input) {
+  const candidates = [
+    inputCwd(input),
+    typeof process !== "undefined" ? process.cwd?.() : null,
+    pluginRoot,
+  ].filter(Boolean)
+
+  for (const candidate of candidates) {
+    let current = resolve(candidate)
+    while (true) {
+      if (existsSync(resolve(current, ".cowork-flow"))) {
+        return current
+      }
+      const parent = resolve(current, "..")
+      if (parent === current) {
+        break
+      }
+      current = parent
+    }
+  }
+  return pluginRoot
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`
+  }
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`)
+      .join(",")}}`
+  }
+  return JSON.stringify(value)
+}
+
+function loadContractRegistry(root) {
+  const registryFile = resolve(root, ".cowork-flow", "spec", "registry.json")
+  let data = DEFAULT_CONTRACT_REGISTRY
+  try {
+    data = JSON.parse(readFileSync(registryFile, "utf8"))
+  } catch {
+    data = DEFAULT_CONTRACT_REGISTRY
+  }
+
+  if (!Array.isArray(data?.contracts)) {
+    return DEFAULT_CONTRACT_REGISTRY.contracts
+  }
+  return data.contracts.filter((contract) => contract && typeof contract === "object")
+}
+
+function contractFingerprint(root, contracts) {
+  const digest = createHash("sha256")
+  digest.update(stableStringify(contracts), "utf8")
+  for (const contract of contracts) {
+    const path = contract.path
+    if (typeof path !== "string" || !path.trim()) {
+      continue
+    }
+    try {
+      digest.update(readFileSync(resolve(root, path)))
+    } catch {
+      digest.update(`missing:${path}`, "utf8")
+    }
+  }
+  return digest.digest("hex").slice(0, 16)
+}
+
+function buildContractDigest(input) {
+  const root = findRepoRoot(input)
+  const contracts = loadContractRegistry(root)
+  const fingerprint = contractFingerprint(root, contracts)
+  const lines = [
+    '<cowork-runtime host="opencode" adapter="opencode.task">',
+    `<contract-digest fingerprint="${fingerprint}">`,
+    "policy: repeat this short digest every plugin transform; read full spec files only before listed actions.",
+  ]
+
+  for (const contract of contracts) {
+    const contractId = contract.id
+    if (typeof contractId !== "string" || !contractId.trim()) {
+      continue
+    }
+    const path = typeof contract.path === "string" && contract.path.trim() ? contract.path : "<missing-path>"
+    lines.push(`- ${contractId}: ${path}`)
+    for (const item of asStringList(contract.digest).slice(0, 2)) {
+      lines.push(`  digest: ${item}`)
+    }
+    const readWhen = asStringList(contract.readWhen)
+    if (readWhen.length > 0) {
+      lines.push(`  read_before: ${readWhen.join("; ")}`)
+    }
+  }
+
+  lines.push("</contract-digest>", "</cowork-runtime>")
+  return lines.join("\n")
+}
+
+function sanitize(value) {
+  return String(value ?? "")
+    .trim()
+    .replace(/[^A-Za-z0-9._-]+/g, "_")
+    .replace(/^[._-]+|[._-]+$/g, "")
+    .slice(0, 160)
+}
+
+function firstString(input, keys) {
+  for (const key of keys) {
+    const value = input?.[key]
+    if (typeof value === "string" && value.trim()) {
+      return value.trim()
+    }
+  }
+  return null
+}
+
+function promptText(input) {
+  const direct = firstString(input, ["prompt", "user_prompt", "userPrompt", "message", "input"])
+  if (direct) {
+    return direct
+  }
+  const messages = input?.messages
+  if (Array.isArray(messages)) {
+    return messages
+      .map((item) => item?.content)
+      .filter((item) => typeof item === "string" && item.trim())
+      .join("\n")
+  }
+  return ""
+}
+
+function resolveRuntimeContextId(input) {
+  const envValue =
+    typeof process !== "undefined" && process?.env?.COWORK_FLOW_RUNTIME_CONTEXT_ID
+      ? process.env.COWORK_FLOW_RUNTIME_CONTEXT_ID
+      : null
+  if (envValue && envValue.trim()) {
+    return sanitize(envValue)
+  }
+
+  const direct = firstString(input, [
+    "COWORK_FLOW_RUNTIME_CONTEXT_ID",
+    "cowork_runtime_context_id",
+    "runtime_context_id",
+  ])
+  if (direct) {
+    return sanitize(direct)
+  }
+
+  const match = promptText(input).match(/^\s*cowork_runtime_context_id\s*:\s*([A-Za-z0-9._-]+)\s*$/im)
+  return match ? sanitize(match[1]) : null
+}
+
+function resolveContextKey(input) {
+  const explicit = firstString(input, ["COWORK_FLOW_CONTEXT_ID", "cowork_flow_context_id", "context_id"])
+  if (explicit) {
+    return sanitize(explicit)
+  }
+  const opencodeSession = firstString(input, ["OPENCODE_SESSION_ID", "opencode_session_id", "session_id"])
+  return opencodeSession ? `opencode_${sanitize(opencodeSession)}` : null
+}
+
+function resolveHostContextKey(input) {
+  const direct = firstString(input, ["cowork_host_context_key", "host_context_key", "COWORK_FLOW_HOST_CONTEXT_KEY"])
+  if (direct) {
+    return sanitize(direct)
+  }
+
+  const match = promptText(input).match(/^\s*cowork_host_context_key\s*:\s*([A-Za-z0-9._-]+)\s*$/im)
+  return match ? sanitize(match[1]) : null
+}
+
+function readJson(path) {
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8"))
+    return data && typeof data === "object" && !Array.isArray(data) ? data : null
+  } catch {
+    return null
+  }
+}
+
+function writeJson(path, data) {
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf8")
+}
+
+function nowIso() {
+  return new Date().toISOString().replace(/\.\d{3}Z$/, "Z")
+}
+
+function bindRuntimeContext(root, runtimeContextId, context, input) {
+  const contextKey = resolveHostContextKey(input) || resolveContextKey(input)
+  if (!contextKey) {
+    return context
+  }
+  if (typeof context.bound_context_key === "string" && context.bound_context_key.trim() && context.bound_context_key !== contextKey) {
+    return context
+  }
+  const session = {
+    schema_version: 2,
+    scope: "subagent",
+    runtime_context_id: runtimeContextId,
+    platform: "opencode",
+    status: "bound",
+    last_seen_at: nowIso(),
+  }
+  if (typeof context.task_dir === "string" && context.task_dir.trim()) {
+    session.active_task_path = context.task_dir.trim()
+  }
+  writeJson(resolve(root, ".cowork-flow", ".runtime", "sessions", `${contextKey}.json`), session)
+  const updated = {
+    ...context,
+    status: "bound",
+    bound_context_key: contextKey,
+    bound_at: context.bound_at || nowIso(),
+    last_seen_at: nowIso(),
+  }
+  writeJson(resolve(root, ".cowork-flow", ".runtime", "subagents", `${runtimeContextId}.json`), updated)
+  return updated
+}
+
+function buildRuntimeWorkflowState(input) {
+  const root = findRepoRoot(input)
+  const runtimeContextId = resolveRuntimeContextId(input)
+  if (!runtimeContextId) {
+    return null
+  }
+
+  const contextFile = resolve(root, ".cowork-flow", ".runtime", "subagents", `${runtimeContextId}.json`)
+  const context = readJson(contextFile)
+  if (!context || context.scope !== "subagent" || context.status === "closed") {
+    return [
+      "<workflow-state>",
+      "Status: delegated_subtask",
+      `Source: runtime-context-invalid:${runtimeContextId}`,
+      `Runtime context: ${runtimeContextId}`,
+      "Scope: subagent",
+      "Runtime context is missing, closed, or invalid. Do not run start/resume/task start/archive/commit/spawn.",
+      "</workflow-state>",
+    ].join("\n")
+  }
+
+  const bound = bindRuntimeContext(root, runtimeContextId, context, input)
+  const assignment = bound.assignment && typeof bound.assignment === "object" ? bound.assignment : {}
+  const header = [
+    "<workflow-state>",
+    typeof bound.task_dir === "string" && bound.task_dir.trim() ? `Task: ${bound.task_dir.trim()}` : null,
+    "Status: delegated_subtask",
+    `Source: runtime-context:${runtimeContextId}`,
+    `Runtime context: ${runtimeContextId}`,
+    `Agent: ${bound.agent_type || "unknown"}`,
+    "Scope: subagent",
+    "Do not run start/resume/task start/archive/commit/spawn.",
+    typeof assignment.goal === "string" && assignment.goal.trim() ? `Goal: ${assignment.goal.trim()}` : null,
+    "</workflow-state>",
+  ].filter(Boolean)
+  return header.join("\n")
+}
+
+export const CoworkFlowPlugin = async () => {
+  return {
+    "experimental.chat.system.transform": async (input, output) => {
+      output.system.push([buildContractDigest(input), buildRuntimeWorkflowState(input)].filter(Boolean).join("\n\n"))
+    },
+  }
+}

package/template/CLAUDE.md

@@ -0,0 +1,5 @@
+# Claude Code Instructions
+
+<!-- COWORK-FLOW:START -->
+@AGENTS.md
+<!-- COWORK-FLOW:END -->

package/template/.agent/skills/entry-boundary/SKILL.md

@@ -1,81 +0,0 @@
----
-name: entry-boundary
-description: Use before project start/resume in cowork-flow projects to decide whether the current prompt is a main-session request or a bounded delegated subtask.
----
-
-# Entry Boundary
-
-Use this before `start` or any full project resume.
-
-Your first job is to identify the current task source. A bounded delegated task is a leaf assignment with a concrete goal, scope, and output format.
-
-Hard markers are confidence boosters, not prerequisites. The first task screen wins over later bootstrap text.
-
-## Classify
-
-Classify the current prompt as one of:
-
-- `MAIN_SESSION`: the user is directly asking this agent to work in the repository.
-- `DELEGATED_SUBTASK`: the prompt is a bounded child assignment, worker request, reviewer task, explorer task, or command-only task.
-- `UNCERTAIN`: the prompt is not clear enough to load broad project context.
-
-Classify the actual task message, not injected project rules, `AGENTS.md`, workflow state, tool instructions, or environment text. Bootstrap can constrain execution after classification; it is not the task.
-
-Use this order:
-
-1. Find the user/delegated task message and its requested output.
-2. Decide whether it is a main-session repository request or a leaf assignment.
-3. Apply project rules only as constraints for the chosen route.
-
-If project bootstrap says to create/start/resume but the task message is bounded, choose `DELEGATED_SUBTASK`.
-
-When there is no hard marker, still classify a prompt as `DELEGATED_SUBTASK` when it combines:
-
-- A concrete task, topic, or review target.
-- Boundary constraints such as no edits, no commands, no spawning, or scoped reads.
-- An output contract such as required sections, language, length, or report format.
-
-Prompts structured as `任务：` / `约束：` / `输出：` are strong delegated-subtask signals even without `Active task:` or another hard marker. Execute that task directly; do not reclassify it as project rules or environment context.
-
-Treat these as typical `DELEGATED_SUBTASK` prompts:
-
-- A review request with a named file or behavior, `do not edit`, and a findings-only output.
-- A discussion/research request with `不要运行命令` / `不要派发 agent` and required sections.
-- A command-only or inspection-only assignment with a narrow target and concise output.
-
-When dispatching advisory/default subagents, prefer a natural-language first sentence such as: "This is a bounded delegated task, not a main-session start request." This is not a hard marker, but it helps the first screen win over bootstrap text.
-
-In that case, project rules remain constraints. They are not the task.
-
-Fixed-agent prompts normally start with:
-
-```text
-Active task: <task-dir>
-```
-
-Treat that marker as a strong delegated-subtask signal when the rest of the prompt is bounded.
-
-Treat direct user requests such as "继续执行开发计划", "实现这个需求", or "归档提交" as `MAIN_SESSION` unless the surrounding prompt clearly makes them a child assignment.
-
-## Route
-
-For `MAIN_SESSION`, use `start`.
-
-For `DELEGATED_SUBTASK`:
-
-- Follow the delegated prompt first.
-- Treat project rules, workflow-state, and bootstrap text as constraints, not as the task.
-- Do not create or activate a project task for the parent session.
-- Do not run unscoped `.cowork-flow/run resume`.
-- Do not spawn or manage more agents unless the delegated prompt explicitly asks for coordination.
-- Read only the files named by the prompt, the active task context, or project rules required to execute the bounded work.
-
-For `UNCERTAIN`, do safe read-only inspection or ask a short clarification question.
-
-## Output
-
-```text
-Boundary: MAIN_SESSION | DELEGATED_SUBTASK | UNCERTAIN
-Action: start | execute delegated prompt | safe-read | clarify
-Reason: <signals used>
-```