@pennixrv/trellis 0.7.1-beta.5 → 0.7.1-beta.6

package/dist/templates/opencode/lib/session-utils.js

@@ -1,11 +1,11 @@
 /* global process */
-import { existsSync, readFileSync, readdirSync, statSync } from "fs"
-import { join } from "path"
-import { execFileSync } from "child_process"
-import { platform } from "os"
-import { debugLog } from "./trellis-context.js"
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { execFileSync } from "child_process";
+import { platform } from "os";
+import { debugLog } from "./trellis-context.js";
 
-const PYTHON_CMD = platform() === "win32" ? "python" : "python3"
+const PYTHON_CMD = platform() === "win32" ? "python" : "python3";
 
 const FIRST_REPLY_NOTICE = `<first-reply-notice>
 On the first visible assistant reply in this session, briefly acknowledge that Trellis SessionStart context loaded.
@@ -16,83 +16,98 @@ Choose the acknowledgment language in this order:
 Continue directly with the user's request after the acknowledgment.
 The acknowledgment must not alter the language used for the remainder of the response.
 This notice is one-shot: do not repeat it after the first visible assistant reply in this session.
-</first-reply-notice>`
+</first-reply-notice>`;
 
 function hasCuratedJsonlEntry(jsonlPath) {
   try {
-    const content = readFileSync(jsonlPath, "utf-8")
+    const content = readFileSync(jsonlPath, "utf-8");
     for (const rawLine of content.split(/\r?\n/)) {
-      const line = rawLine.trim()
-      if (!line) continue
+      const line = rawLine.trim();
+      if (!line) continue;
       try {
-        const row = JSON.parse(line)
-        if (row && typeof row === "object" && typeof row.file === "string" && row.file) {
-          return true
+        const row = JSON.parse(line);
+        if (
+          row &&
+          typeof row === "object" &&
+          typeof row.file === "string" &&
+          row.file
+        ) {
+          return true;
         }
       } catch {
         // Ignore malformed line
       }
     }
   } catch {
-    return false
+    return false;
   }
-  return false
+  return false;
 }
 
 function getTaskStatus(ctx, platformInput = null) {
-  const active = ctx.getActiveTask(platformInput)
-  const taskRef = active.taskPath
+  const active = ctx.getActiveTask(platformInput);
+  const taskRef = active.taskPath;
   if (!taskRef) {
     return (
       "Status: NO ACTIVE TASK\n" +
       "Next-Action: Classify the current turn before creating any Trellis task. " +
       "Simple conversation / small task asks only whether this turn should create a Trellis task. " +
       "Complex task asks whether task creation and planning are allowed."
-    )
+    );
   }
 
-  const taskDir = ctx.resolveTaskDir(taskRef)
+  const taskDir = ctx.resolveTaskDir(taskRef);
 
   if (active.stale || !taskDir || !existsSync(taskDir)) {
-    return `Status: STALE POINTER\nTask: ${taskRef}\nNext-Action: Task directory not found. Run: python3 ./.trellis/scripts/task.py finish`
+    return `Status: STALE POINTER\nTask: ${taskRef}\nNext-Action: Task directory not found. Run: python3 ./.trellis/scripts/task.py finish`;
   }
 
-  let taskData = {}
-  const taskJsonPath = join(taskDir, "task.json")
+  let taskData = {};
+  const taskJsonPath = join(taskDir, "task.json");
   if (existsSync(taskJsonPath)) {
     try {
-      taskData = JSON.parse(readFileSync(taskJsonPath, "utf-8"))
+      taskData = JSON.parse(readFileSync(taskJsonPath, "utf-8"));
     } catch {
       // Ignore parse errors
     }
   }
 
-  const taskTitle = taskData.title || taskRef
-  const taskStatus = taskData.status || "unknown"
+  const taskTitle = taskData.title || taskRef;
+  const taskStatus = taskData.status || "unknown";
 
   if (taskStatus === "completed") {
-    return `Status: COMPLETED\nTask: ${taskTitle}\nNext-Action: Start another task or end the session; finish-work only records the session journal.`
+    return `Status: COMPLETED\nTask: ${taskTitle}\nNext-Action: Start another task or end the session; finish-work only records the session journal.`;
   }
 
-  const artifactNames = ["prd.md", "design.md", "implement.md", "implement.jsonl", "check.jsonl"]
-  const present = artifactNames.filter(name => existsSync(join(taskDir, name)))
-  if (existsSync(join(taskDir, "research"))) present.push("research/")
-  const presentLine = present.length > 0 ? present.join(", ") : "(none)"
-  const implementJsonl = join(taskDir, "implement.jsonl")
-  const checkJsonl = join(taskDir, "check.jsonl")
+  const artifactNames = [
+    "prd.md",
+    "design.md",
+    "implement.md",
+    "implement.jsonl",
+    "check.jsonl",
+  ];
+  const present = artifactNames.filter((name) =>
+    existsSync(join(taskDir, name)),
+  );
+  if (existsSync(join(taskDir, "research"))) present.push("research/");
+  const presentLine = present.length > 0 ? present.join(", ") : "(none)";
+  const implementJsonl = join(taskDir, "implement.jsonl");
+  const checkJsonl = join(taskDir, "check.jsonl");
   const jsonlReady =
     (!existsSync(implementJsonl) || hasCuratedJsonlEntry(implementJsonl)) &&
-    (!existsSync(checkJsonl) || hasCuratedJsonlEntry(checkJsonl))
+    (!existsSync(checkJsonl) || hasCuratedJsonlEntry(checkJsonl));
 
   if (taskStatus === "planning") {
     const nextBits = [
       "Follow the current per-turn workflow-state; task lifecycle status and artifact presence do not identify the business phase",
       "If no phase route is initialized, load `trellis-goal-exploration-and-requirements` and confirm the requirements baseline before initializing the route",
-    ]
+    ];
     if (!jsonlReady) {
-      nextBits.push("curate task context manifests only when a dispatched agent needs them")
+      nextBits.push(
+        "curate task context manifests only when a dispatched agent needs them",
+      );
     }
-    return `Status: PLANNING\nTask: ${taskTitle}\nPresent: ${presentLine}\nNext-Action: ${nextBits.join("; ")}. Do not enter implementation until the user confirms start.`
+    return `Status: PLANNING\nTask: ${taskTitle}\nPresent: ${presentLine}\nNext-Action: ${nextBits.join("; ")}. Do not enter implementation until the user confirms start.`;
   }
 
   return (
@@ -100,32 +115,48 @@ function getTaskStatus(ctx, platformInput = null) {
     `Present: ${presentLine}\n` +
     "Next-Action: Follow the matching per-turn workflow-state; task lifecycle status does not identify the business phase. " +
     "Implementation/check context order is jsonl entries -> `prd.md` -> `design.md if present` -> `implement.md if present`."
-  )
+  );
 }
 
 function loadTrellisConfig(directory, contextKey = null) {
-  const scriptPath = join(directory, ".trellis", "scripts", "get_context.py")
+  const scriptPath = join(directory, ".trellis", "scripts", "get_context.py");
   if (!existsSync(scriptPath)) {
-    return { isMonorepo: false, packages: {}, specScope: null, activeTaskPackage: null, defaultPackage: null }
+    return {
+      isMonorepo: false,
+      packages: {},
+      specScope: null,
+      activeTaskPackage: null,
+      defaultPackage: null,
+    };
   }
   try {
-    const output = execFileSync(PYTHON_CMD, [scriptPath, "--mode", "packages", "--json"], {
-      cwd: directory,
-      timeout: 5000,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        ...(contextKey ? { TRELLIS_CONTEXT_ID: contextKey } : {}),
+    const output = execFileSync(
+      PYTHON_CMD,
+      [scriptPath, "--mode", "packages", "--json"],
+      {
+        cwd: directory,
+        timeout: 5000,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          ...(contextKey ? { TRELLIS_CONTEXT_ID: contextKey } : {}),
+        },
       },
-    })
-    const data = JSON.parse(output)
+    );
+    const data = JSON.parse(output);
     if (data.mode !== "monorepo") {
-      return { isMonorepo: false, packages: {}, specScope: null, activeTaskPackage: null, defaultPackage: null }
+      return {
+        isMonorepo: false,
+        packages: {},
+        specScope: null,
+        activeTaskPackage: null,
+        defaultPackage: null,
+      };
     }
-    const pkgDict = {}
-    for (const pkg of (data.packages || [])) {
-      pkgDict[pkg.name] = pkg
+    const pkgDict = {};
+    for (const pkg of data.packages || []) {
+      pkgDict[pkg.name] = pkg;
     }
     return {
       isMonorepo: true,
@@ -133,34 +164,40 @@ function loadTrellisConfig(directory, contextKey = null) {
       specScope: data.specScope || null,
       activeTaskPackage: data.activeTaskPackage || null,
       defaultPackage: data.defaultPackage || null,
-    }
+    };
   } catch (e) {
-    debugLog("session", "loadTrellisConfig error:", e.message)
-    return { isMonorepo: false, packages: {}, specScope: null, activeTaskPackage: null, defaultPackage: null }
+    debugLog("session", "loadTrellisConfig error:", e.message);
+    return {
+      isMonorepo: false,
+      packages: {},
+      specScope: null,
+      activeTaskPackage: null,
+      defaultPackage: null,
+    };
   }
 }
 
 function checkLegacySpec(directory, config) {
   if (!config.isMonorepo || Object.keys(config.packages).length === 0) {
-    return null
+    return null;
   }
 
-  const specDir = join(directory, ".trellis", "spec")
-  if (!existsSync(specDir)) return null
+  const specDir = join(directory, ".trellis", "spec");
+  if (!existsSync(specDir)) return null;
 
-  let hasLegacy = false
+  let hasLegacy = false;
   for (const name of ["backend", "frontend"]) {
     if (existsSync(join(specDir, name, "index.md"))) {
-      hasLegacy = true
-      break
+      hasLegacy = true;
+      break;
     }
   }
-  if (!hasLegacy) return null
+  if (!hasLegacy) return null;
 
-  const pkgNames = Object.keys(config.packages).sort()
-  const missing = pkgNames.filter(name => !existsSync(join(specDir, name)))
+  const pkgNames = Object.keys(config.packages).sort();
+  const missing = pkgNames.filter((name) => !existsSync(join(specDir, name)));
 
-  if (missing.length === 0) return null
+  if (missing.length === 0) return null;
 
   if (missing.length === pkgNames.length) {
     return (
@@ -168,84 +205,92 @@ function checkLegacySpec(directory, config) {
       `but no package-scoped \`spec/<package>/\` directories.\n` +
       `Monorepo packages: ${pkgNames.join(", ")}\n` +
       `Please reorganize: \`spec/backend/\` -> \`spec/<package>/backend/\``
-    )
+    );
   }
   return (
     `[!] Partial spec migration detected: packages ${missing.join(", ")} ` +
     `still missing \`spec/<pkg>/\` directory.\n` +
     `Please complete migration for all packages.`
-  )
+  );
 }
 
 function resolveSpecScope(config) {
   if (!config.isMonorepo || Object.keys(config.packages).length === 0) {
-    return null
+    return null;
   }
 
-  const { specScope, activeTaskPackage, defaultPackage, packages } = config
-  if (specScope == null) return null
+  const { specScope, activeTaskPackage, defaultPackage, packages } = config;
+  if (specScope == null) return null;
 
   if (specScope === "active_task") {
-    if (activeTaskPackage && activeTaskPackage in packages) return new Set([activeTaskPackage])
-    if (defaultPackage && defaultPackage in packages) return new Set([defaultPackage])
-    return null
+    if (activeTaskPackage && activeTaskPackage in packages)
+      return new Set([activeTaskPackage]);
+    if (defaultPackage && defaultPackage in packages)
+      return new Set([defaultPackage]);
+    return null;
   }
 
   if (Array.isArray(specScope)) {
-    const valid = new Set()
+    const valid = new Set();
     for (const entry of specScope) {
       if (entry in packages) {
-        valid.add(entry)
+        valid.add(entry);
       }
     }
-    if (valid.size > 0) return valid
-    if (activeTaskPackage && activeTaskPackage in packages) return new Set([activeTaskPackage])
-    if (defaultPackage && defaultPackage in packages) return new Set([defaultPackage])
-    return null
+    if (valid.size > 0) return valid;
+    if (activeTaskPackage && activeTaskPackage in packages)
+      return new Set([activeTaskPackage]);
+    if (defaultPackage && defaultPackage in packages)
+      return new Set([defaultPackage]);
+    return null;
   }
 
-  return null
+  return null;
 }
 
 function collectSpecIndexPaths(directory, allowedPkgs) {
-  const specDir = join(directory, ".trellis", "spec")
-  const paths = []
+  const specDir = join(directory, ".trellis", "spec");
+  const paths = [];
 
-  const guidesIndex = join(specDir, "guides", "index.md")
+  const guidesIndex = join(specDir, "guides", "index.md");
   if (existsSync(guidesIndex)) {
-    paths.push(".trellis/spec/guides/index.md")
+    paths.push(".trellis/spec/guides/index.md");
   }
 
-  if (!existsSync(specDir)) return paths
+  if (!existsSync(specDir)) return paths;
 
   try {
-    const subs = readdirSync(specDir).filter(name => {
-      if (name.startsWith(".") || name === "guides") return false
-      try {
-        return statSync(join(specDir, name)).isDirectory()
-      } catch {
-        return false
-      }
-    }).sort()
+    const subs = readdirSync(specDir)
+      .filter((name) => {
+        if (name.startsWith(".") || name === "guides") return false;
+        try {
+          return statSync(join(specDir, name)).isDirectory();
+        } catch {
+          return false;
+        }
+      })
+      .sort();
 
     for (const sub of subs) {
-      const indexFile = join(specDir, sub, "index.md")
+      const indexFile = join(specDir, sub, "index.md");
       if (existsSync(indexFile)) {
-        paths.push(`.trellis/spec/${sub}/index.md`)
+        paths.push(`.trellis/spec/${sub}/index.md`);
       } else {
-        if (allowedPkgs !== null && !allowedPkgs.has(sub)) continue
+        if (allowedPkgs !== null && !allowedPkgs.has(sub)) continue;
         try {
-          const nested = readdirSync(join(specDir, sub)).filter(name => {
-            try {
-              return statSync(join(specDir, sub, name)).isDirectory()
-            } catch {
-              return false
-            }
-          }).sort()
+          const nested = readdirSync(join(specDir, sub))
+            .filter((name) => {
+              try {
+                return statSync(join(specDir, sub, name)).isDirectory();
+              } catch {
+                return false;
+              }
+            })
+            .sort();
           for (const layer of nested) {
-            const nestedIndex = join(specDir, sub, layer, "index.md")
+            const nestedIndex = join(specDir, sub, layer, "index.md");
             if (existsSync(nestedIndex)) {
-              paths.push(`.trellis/spec/${sub}/${layer}/index.md`)
+              paths.push(`.trellis/spec/${sub}/${layer}/index.md`);
             }
           }
         } catch {
@@ -257,19 +302,22 @@ function collectSpecIndexPaths(directory, allowedPkgs) {
     // Ignore spec directory read errors
   }
 
-  return paths
+  return paths;
 }
 
 function readDeveloper(directory) {
   try {
-    const content = readFileSync(join(directory, ".trellis", ".developer"), "utf-8")
+    const content = readFileSync(
+      join(directory, ".trellis", ".developer"),
+      "utf-8",
+    );
     for (const line of content.split(/\r?\n/)) {
-      if (line.startsWith("name=")) return line.slice("name=".length).trim()
+      if (line.startsWith("name=")) return line.slice("name=".length).trim();
     }
   } catch {
     // Ignore missing developer file
   }
-  return "(not initialized)"
+  return "(not initialized)";
 }
 
 function runGit(directory, args) {
@@ -279,63 +327,90 @@ function runGit(directory, args) {
       timeout: 3000,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
-    }).trim()
+    }).trim();
   } catch {
-    return ""
+    return "";
   }
 }
 
 function buildCompactCurrentState(ctx, platformInput, specIndexPaths) {
-  const directory = ctx.directory
-  const lines = []
-  lines.push(`Developer: ${readDeveloper(directory)}`)
+  const directory = ctx.directory;
+  const lines = [];
+  lines.push(`Developer: ${readDeveloper(directory)}`);
 
-  const branch = runGit(directory, ["branch", "--show-current"]) || "(detached)"
+  const branch =
+    runGit(directory, ["branch", "--show-current"]) || "(detached)";
   const dirtyCount = runGit(directory, ["status", "--porcelain"])
     .split(/\r?\n/)
-    .filter(line => line.trim()).length
-  lines.push(`Git: branch ${branch}; ${dirtyCount === 0 ? "clean" : `dirty ${dirtyCount} paths`}.`)
+    .filter((line) => line.trim()).length;
+  lines.push(
+    `Git: branch ${branch}; ${dirtyCount === 0 ? "clean" : `dirty ${dirtyCount} paths`}.`,
+  );
 
-  const active = ctx.getActiveTask(platformInput)
+  const active = ctx.getActiveTask(platformInput);
   if (active.taskPath) {
-    const taskDir = ctx.resolveTaskDir(active.taskPath)
-    let status = "unknown"
+    const taskDir = ctx.resolveTaskDir(active.taskPath);
+    let status = "unknown";
     if (taskDir) {
       try {
-        const data = JSON.parse(readFileSync(join(taskDir, "task.json"), "utf-8"))
-        status = data.status || "unknown"
+        const data = JSON.parse(
+          readFileSync(join(taskDir, "task.json"), "utf-8"),
+        );
+        status = data.status || "unknown";
       } catch {
         // Ignore parse errors
       }
     }
-    lines.push(`Current task: ${active.taskPath}; status=${status}.`)
+    lines.push(`Current task: ${active.taskPath}; status=${status}.`);
   } else {
-    lines.push("Current task: none.")
+    lines.push("Current task: none.");
   }
 
-  const tasksDir = join(directory, ".trellis", "tasks")
+  const tasksDir = join(directory, ".trellis", "tasks");
   if (existsSync(tasksDir)) {
     try {
-      const activeTasks = readdirSync(tasksDir, { withFileTypes: true })
-        .filter(entry => entry.isDirectory() && entry.name !== "archive" && existsSync(join(tasksDir, entry.name, "task.json")))
-      lines.push(`Active tasks: ${activeTasks.length} total. Use \`python3 ./.trellis/scripts/task.py list --mine\` only if needed.`)
+      const result = JSON.parse(
+        execFileSync(
+          PYTHON_CMD,
+          [join(directory, ".trellis", "scripts", "task.py"), "list", "--json"],
+          {
+            cwd: directory,
+            encoding: "utf-8",
+            timeout: 5000,
+            stdio: ["ignore", "pipe", "pipe"],
+          },
+        ),
+      );
+      const activeTasks = result.tasks.filter((task) =>
+        ["planning", "in_progress"].includes(task.status),
+      );
+      lines.push(
+        `Active tasks: ${activeTasks.length} total. Use \`python3 ./.trellis/scripts/task.py list --mine\` only if needed.`,
+      );
     } catch {
       // Ignore task list errors
     }
   }
 
-  const developer = readDeveloper(directory)
-  const workspaceDir = join(directory, ".trellis", "workspace", developer)
+  const developer = readDeveloper(directory);
+  const workspaceDir = join(directory, ".trellis", "workspace", developer);
   if (developer !== "(not initialized)" && existsSync(workspaceDir)) {
     try {
       const journals = readdirSync(workspaceDir)
-        .filter(name => /^journal-\d+\.md$/.test(name))
-        .sort((a, b) => Number(a.match(/\d+/)?.[0] || 0) - Number(b.match(/\d+/)?.[0] || 0))
-      const journal = journals[journals.length - 1]
+        .filter((name) => /^journal-\d+\.md$/.test(name))
+        .sort(
+          (a, b) =>
+            Number(a.match(/\d+/)?.[0] || 0) - Number(b.match(/\d+/)?.[0] || 0),
+        );
+      const journal = journals[journals.length - 1];
       if (journal) {
-        const journalPath = join(workspaceDir, journal)
-        const lineCount = readFileSync(journalPath, "utf-8").split(/\r?\n/).length
-        lines.push(`Journal: .trellis/workspace/${developer}/${journal}, ${lineCount} / 2000 lines.`)
+        const journalPath = join(workspaceDir, journal);
+        const lineCount = readFileSync(journalPath, "utf-8").split(
+          /\r?\n/,
+        ).length;
+        lines.push(
+          `Journal: .trellis/workspace/${developer}/${journal}, ${lineCount} / 2000 lines.`,
+        );
       }
     } catch {
       // Ignore journal errors
@@ -343,180 +418,197 @@ function buildCompactCurrentState(ctx, platformInput, specIndexPaths) {
   }
 
   if (specIndexPaths.length > 0) {
-    lines.push(`Spec indexes: ${specIndexPaths.length} available.`)
+    lines.push(`Spec indexes: ${specIndexPaths.length} available.`);
   }
 
-  return lines.join("\n")
+  return lines.join("\n");
 }
 
 export function buildSessionContext(ctx, platformInput = null) {
-  const directory = ctx.directory
-  const contextKey = typeof ctx.getContextKey === "function"
-    ? ctx.getContextKey(platformInput)
-    : null
+  const directory = ctx.directory;
+  const contextKey =
+    typeof ctx.getContextKey === "function"
+      ? ctx.getContextKey(platformInput)
+      : null;
 
-  const config = loadTrellisConfig(directory, contextKey)
-  const allowedPkgs = resolveSpecScope(config)
-  const paths = collectSpecIndexPaths(directory, allowedPkgs)
+  const config = loadTrellisConfig(directory, contextKey);
+  const allowedPkgs = resolveSpecScope(config);
+  const paths = collectSpecIndexPaths(directory, allowedPkgs);
 
-  const parts = []
+  const parts = [];
 
   parts.push(`<session-context>
 Trellis compact SessionStart context. Use it to orient the session; load details on demand.
-</session-context>`)
-  parts.push(FIRST_REPLY_NOTICE)
+</session-context>`);
+  parts.push(FIRST_REPLY_NOTICE);
 
-  const legacyWarning = checkLegacySpec(directory, config)
+  const legacyWarning = checkLegacySpec(directory, config);
   if (legacyWarning) {
-    parts.push(`<migration-warning>\n${legacyWarning}\n</migration-warning>`)
+    parts.push(`<migration-warning>\n${legacyWarning}\n</migration-warning>`);
   }
 
-  parts.push("<current-state>")
-  parts.push(buildCompactCurrentState(ctx, platformInput, paths))
-  parts.push("</current-state>")
+  parts.push("<current-state>");
+  parts.push(buildCompactCurrentState(ctx, platformInput, paths));
+  parts.push("</current-state>");
 
-  const workflowContent = ctx.readProjectFile(".trellis/workflow.md")
+  const workflowContent = ctx.readProjectFile(".trellis/workflow.md");
   if (workflowContent) {
-    const allLines = workflowContent.split("\n")
+    const allLines = workflowContent.split("\n");
     const overviewLines = [
       "# 工作流会话摘要",
       "完整说明：.trellis/workflow.md。阶段详情：读取当前阶段提示指定的 Skill。",
       "",
-    ]
+    ];
 
-    let rangeStart = -1
-    let rangeEnd = allLines.length
+    let rangeStart = -1;
+    let rangeEnd = allLines.length;
     for (let i = 0; i < allLines.length; i++) {
-      const stripped = allLines[i].trim()
-      const heading = stripped.replace(/^#{2,3}\s+/, "")
+      const stripped = allLines[i].trim();
+      const heading = stripped.replace(/^#{2,3}\s+/, "");
       const isPhaseHeading =
         /^#{2,3}\s+/.test(stripped) &&
-        ["目标探索与需求核对阶段", "Goal Exploration and Requirements Confirmation Phase"].some(
+        [
+          "目标探索与需求核对阶段",
+          "Goal Exploration and Requirements Confirmation Phase",
+        ].some(
           (title) =>
             heading === title ||
             heading.endsWith(`：${title}`) ||
             heading.endsWith(`: ${title}`),
-        )
-      if (rangeStart === -1 && ["## 阶段索引", "## Phase Index"].includes(stripped)) {
-        rangeStart = i
+        );
+      if (
+        rangeStart === -1 &&
+        ["## 阶段索引", "## Phase Index"].includes(stripped)
+      ) {
+        rangeStart = i;
       } else if (rangeStart !== -1 && isPhaseHeading) {
-        rangeEnd = i
-        break
+        rangeEnd = i;
+        break;
       }
     }
     if (rangeStart !== -1) {
       const strippedStateBlocks = allLines
         .slice(rangeStart, rangeEnd)
         .join("\n")
-        .replace(/\[workflow-state:([A-Za-z0-9_-]+)\]\s*\n[\s\S]*?\n\s*\[\/workflow-state:\1\]\n?/g, "")
+        .replace(
+          /\[workflow-state:([A-Za-z0-9_-]+)\]\s*\n[\s\S]*?\n\s*\[\/workflow-state:\1\]\n?/g,
+          "",
+        )
         .replace(/<!--[\s\S]*?-->/g, "")
         .replace(/^\[(?!\/?workflow-state:)\/?[^\]\n]+\]\s*\n?/gm, "")
-        .replace(/\n{3,}/g, "\n\n")
-      overviewLines.push(strippedStateBlocks.trimEnd())
+        .replace(/\n{3,}/g, "\n\n");
+      overviewLines.push(strippedStateBlocks.trimEnd());
     }
 
-    parts.push("<trellis-workflow>")
-    parts.push(overviewLines.join("\n").trimEnd())
-    parts.push("</trellis-workflow>")
+    parts.push("<trellis-workflow>");
+    parts.push(overviewLines.join("\n").trimEnd());
+    parts.push("</trellis-workflow>");
   }
 
-  parts.push("<guidelines>")
+  parts.push("<guidelines>");
   parts.push(
     "Task context order for implementation/check: jsonl entries -> `prd.md` -> " +
-    "`design.md if present` -> `implement.md if present`. Missing optional artifacts " +
-    "are skipped for lightweight tasks.\n"
-  )
+      "`design.md if present` -> `implement.md if present`. Missing optional artifacts " +
+      "are skipped for lightweight tasks.\n",
+  );
 
   if (paths.length > 0) {
-    parts.push("## Available indexes (read on demand)")
+    parts.push("## Available indexes (read on demand)");
     for (const p of paths) {
-      parts.push(`- ${p}`)
+      parts.push(`- ${p}`);
     }
-    parts.push("")
+    parts.push("");
   }
 
   parts.push(
     "Discover more via: " +
-    "`python3 ./.trellis/scripts/get_context.py --mode packages`"
-  )
-  parts.push("</guidelines>")
+      "`python3 ./.trellis/scripts/get_context.py --mode packages`",
+  );
+  parts.push("</guidelines>");
 
-  const taskStatus = getTaskStatus(ctx, platformInput)
-  parts.push(`<task-status>\n${taskStatus}\n</task-status>`)
+  const taskStatus = getTaskStatus(ctx, platformInput);
+  parts.push(`<task-status>\n${taskStatus}\n</task-status>`);
 
   parts.push(`<ready>
 Context loaded. Follow <task-status>. Load workflow/spec/task details only when needed.
-</ready>`)
+</ready>`);
 
-  return parts.join("\n\n")
+  return parts.join("\n\n");
 }
 
 function getTrellisMetadata(metadata) {
   if (!metadata || typeof metadata !== "object") {
-    return {}
+    return {};
   }
 
-  const trellis = metadata.trellis
+  const trellis = metadata.trellis;
   if (!trellis || typeof trellis !== "object") {
-    return {}
+    return {};
   }
 
-  return trellis
+  return trellis;
 }
 
 function markPartAsSessionStart(part) {
-  const metadata = part.metadata && typeof part.metadata === "object"
-    ? part.metadata
-    : {}
+  const metadata =
+    part.metadata && typeof part.metadata === "object" ? part.metadata : {};
   part.metadata = {
     ...metadata,
     trellis: {
       ...getTrellisMetadata(metadata),
       sessionStart: true,
     },
-  }
+  };
 }
 
 function hasSessionStartMarker(part) {
   if (!part || part.type !== "text" || typeof part.text !== "string") {
-    return false
+    return false;
   }
 
-  return getTrellisMetadata(part.metadata).sessionStart === true
+  return getTrellisMetadata(part.metadata).sessionStart === true;
 }
 
 export function hasInjectedTrellisContext(messages) {
   if (!Array.isArray(messages)) {
-    return false
+    return false;
   }
 
-  return messages.some(message => {
-    if (!message?.info || message.info.role !== "user" || !Array.isArray(message.parts)) {
-      return false
+  return messages.some((message) => {
+    if (
+      !message?.info ||
+      message.info.role !== "user" ||
+      !Array.isArray(message.parts)
+    ) {
+      return false;
     }
 
-    return message.parts.some(hasSessionStartMarker)
-  })
+    return message.parts.some(hasSessionStartMarker);
+  });
 }
 
-export async function hasPersistedInjectedContext(client, directory, sessionID) {
+export async function hasPersistedInjectedContext(
+  client,
+  directory,
+  sessionID,
+) {
   try {
     const response = await client.session.messages({
       path: { id: sessionID },
       query: { directory },
       throwOnError: true,
-    })
-    return hasInjectedTrellisContext(response.data || [])
+    });
+    return hasInjectedTrellisContext(response.data || []);
   } catch (error) {
     debugLog(
       "session",
       "Failed to read session history for dedupe:",
       error instanceof Error ? error.message : String(error),
-    )
-    return false
+    );
+    return false;
   }
 }
 
 export function markContextInjected(part) {
-  markPartAsSessionStart(part)
+  markPartAsSessionStart(part);
 }