@pennixrv/trellis 0.6.40 → 0.6.43

package/dist/migrations/manifests/0.6.41.json

@@ -0,0 +1,9 @@
+{
+  "version": "0.6.41",
+  "description": "Restores active-task visibility when a host context key has no persisted session file.",
+  "breaking": false,
+  "recommendMigrate": false,
+  "changelog": "**Fix:**\n- Projects one unique developer-owned resumable task as read-only workflow context when the host provides a context key whose session file is missing, while still refusing to guess when another session pointer exists.",
+  "migrations": [],
+  "notes": "No project migration is required. Existing projects can run the normal trellis update flow."
+}

package/dist/migrations/manifests/0.6.42.json

@@ -0,0 +1,9 @@
+{
+  "version": "0.6.42",
+  "description": "Isolates unbound task resolution from unrelated session fallback inference.",
+  "breaking": false,
+  "recommendMigrate": false,
+  "changelog": "**Fix:**\n- Stop the default task resolver from borrowing a task from a sole unrelated session file, while preserving read-only unbound task and ambiguity projections.",
+  "migrations": [],
+  "notes": "No project migration is required. Existing projects can run the normal trellis update flow."
+}

package/dist/migrations/manifests/0.6.43.json

@@ -0,0 +1,9 @@
+{
+  "version": "0.6.43",
+  "description": "Ships the isolated active-task resolver to the dogfood script tree.",
+  "breaking": false,
+  "recommendMigrate": false,
+  "changelog": "**Fix:**\n- Keep the dogfood and published active-task resolver scripts synchronized so isolated session fallback behavior is identical in development and installed projects.",
+  "migrations": [],
+  "notes": "No project migration is required. Existing projects can run the normal trellis update flow."
+}

package/dist/templates/codex/hooks/session-start.py

@@ -229,6 +229,14 @@ def _resolve_task_dir(trellis_dir: Path, task_ref: str) -> Path:
 
 def _get_task_status(trellis_dir: Path, hook_input: dict) -> str:
     active = _resolve_active_task(trellis_dir, hook_input)
+    if active.source_type == "unbound_ambiguous":
+        candidates = "\n".join(f"- {candidate}" for candidate in active.candidate_paths)
+        return (
+            "Status: TASK BINDING AMBIGUOUS\n"
+            f"Candidates:\n{candidates}\n"
+            "Next: Review the candidates and run `python3 ./.trellis/scripts/task.py start <task>` "
+            "with the intended task once a direct session identity is available."
+        )
     if not active.task_path:
         return (
             "Status: NO ACTIVE TASK\n"
@@ -383,7 +391,10 @@ def _build_compact_current_state(
     lines.append(_format_git_state(repo_root))
 
     active = _resolve_active_task(trellis_dir, hook_input)
-    if active.task_path:
+    if active.source_type == "unbound_ambiguous":
+        candidates = ", ".join(active.candidate_paths)
+        lines.append(f"Current task: ambiguous; candidates={candidates}; bind explicitly.")
+    elif active.task_path:
         task_dir = _resolve_task_dir(trellis_dir, active.task_path)
         status = "unknown"
         task_json = task_dir / "task.json"

package/dist/templates/opencode/lib/trellis-context.js

@@ -373,7 +373,8 @@ export class TrellisContext {
    *
    * Resolution order (mirrors Python `active_task.resolve_active_task`):
    *   1. Lookup the runtime file for the input-derived context key. A known
-   *      key is authoritative, so a missing or empty context returns no task.
+   *      key is authoritative when it contains a task; a missing or empty
+   *      context may use the guarded unbound-task projection.
    *   2. If no context key is available and exactly one session runtime file
    *      exists locally, use it (`_resolveSingleSessionFallback`). Refuses to
    *      guess when 0 or ≥2 files exist so multi-window isolation holds.
@@ -393,6 +394,10 @@ export class TrellisContext {
           stale: !taskDir || !existsSync(taskDir),
         }
       }
+      const unbound = this._resolveUnboundTask()
+      if (unbound) {
+        return unbound
+      }
       return { taskPath: null, source: "none", stale: false }
     }
 
@@ -456,7 +461,14 @@ export class TrellisContext {
       } catch {
         return null
       }
-      if (sessionFiles.length > 0) return null
+      if (sessionFiles.some(file => {
+        try {
+          const context = JSON.parse(readFileSync(join(sessionsDir, file), "utf-8"))
+          return Boolean(this.normalizeTaskRef(context?.current_task || ""))
+        } catch {
+          return false
+        }
+      })) return null
     }
 
     const developer = (process.env.TRELLIS_DEVELOPER || "").trim() || (() => {
@@ -486,8 +498,16 @@ export class TrellisContext {
         return []
       }
     })
-    if (candidates.length !== 1) return null
-    return { taskPath: candidates[0], source: "unbound", stale: false }
+    if (candidates.length === 0) return null
+    if (candidates.length === 1) {
+      return { taskPath: candidates[0], source: "unbound", stale: false }
+    }
+    return {
+      taskPath: null,
+      source: "unbound_ambiguous",
+      stale: false,
+      candidatePaths: candidates.sort(),
+    }
   }
 
   getCurrentTask(platformInput = null) {

package/dist/templates/opencode/plugins/inject-workflow-state.js

@@ -143,6 +143,14 @@ function loadBreadcrumbs(directory) {
  */
 function getActiveTask(ctx, platformInput = null) {
   const active = ctx.getActiveTask(platformInput)
+  if (active.source === "unbound_ambiguous") {
+    return {
+      id: null,
+      status: "unbound_ambiguous",
+      source: active.source,
+      candidates: active.candidatePaths || [],
+    }
+  }
   const taskRef = active.taskPath
   if (!taskRef) return null
   const taskDir = ctx.resolveTaskDir(taskRef)
@@ -170,12 +178,17 @@ function getActiveTask(ctx, platformInput = null) {
  *   "Refer to workflow.md for current step." line
  * - no_task pseudo-status (id === null) → header omits task info
  */
-function buildBreadcrumb(id, status, templates) {
+function buildBreadcrumb(id, status, templates, candidates = []) {
   let body = templates[status]
   if (body === undefined) {
     body = "Refer to workflow.md for current step."
   }
-  let header = id === null ? `Status: ${status}` : `Task: ${id} (${status})`
+  let header
+  if (status === "unbound_ambiguous") {
+    header = `Status: ${status}\nCandidates: ${candidates.join(", ")}`
+  } else {
+    header = id === null ? `Status: ${status}` : `Task: ${id} (${status})`
+  }
   return `<workflow-state>\n${header}\n${body}\n</workflow-state>`
 }
 
@@ -218,7 +231,7 @@ export default async ({ directory }) => {
           const templates = loadBreadcrumbs(directory)
           const task = getActiveTask(ctx, platformInput)
           const breadcrumb = task
-            ? buildBreadcrumb(task.id, task.status, templates, task.source)
+            ? buildBreadcrumb(task.id, task.status, templates, task.candidates)
             : buildBreadcrumb(null, "no_task", templates)
 
           prependEphemeralText(messages, breadcrumb)

package/dist/templates/shared-hooks/inject-subagent-context.py

@@ -149,7 +149,7 @@ def get_current_task(
     input_data: dict,
     *,
     platform: str | None = None,
-    allow_single_session_fallback: bool = True,
+    allow_single_session_fallback: bool = False,
     allow_environment_context: bool = True,
     require_existing: bool = False,
 ) -> str | None:
@@ -740,7 +740,11 @@ def main():
         sys.exit(0)
 
     # Get current task directory (research doesn't require it)
-    task_dir = get_current_task(repo_root, input_data)
+    task_dir = get_current_task(
+        repo_root,
+        input_data,
+        allow_single_session_fallback=True,
+    )
 
     # implement/check need task directory
     if subagent_type in AGENTS_REQUIRE_TASK:

package/dist/templates/shared-hooks/inject-workflow-state.py

@@ -169,6 +169,9 @@ def get_active_task(
     prompt.
     """
     active = _resolve_active_task(root, input_data)
+    if active.source_type == "unbound_ambiguous":
+        candidates = ", ".join(active.candidate_paths)
+        return candidates, "unbound_ambiguous", active.source
     if not active.task_path:
         return None
 
@@ -379,7 +382,10 @@ def build_breadcrumb(
         body = templates.get(status)
     if body is None:
         body = "Refer to workflow.md for current step."
-    header = f"Status: {status}" if task_id is None else f"Task: {task_id} ({status})"
+    if status == "unbound_ambiguous":
+        header = f"Status: {status}\nCandidates: {task_id}"
+    else:
+        header = f"Status: {status}" if task_id is None else f"Task: {task_id} ({status})"
     return f"<workflow-state>\n{header}\n{body}\n</workflow-state>"
 
 

package/dist/templates/trellis/scripts/common/active_task.py

@@ -2,8 +2,8 @@
 """Session-scoped active task resolution.
 
 The user-facing concept is a single "active task". Trellis stores that pointer
-per AI session/window under `.trellis/.runtime/sessions/`; without a stable
-session key there is no active task.
+per AI session/window under `.trellis/.runtime/sessions/`; when the pointer is
+missing, a unique developer-owned resumable task may be exposed read-only.
 """
 
 from __future__ import annotations
@@ -168,6 +168,7 @@ class ActiveTask:
     source_type: str
     context_key: str | None = None
     stale: bool = False
+    candidate_paths: tuple[str, ...] = ()
 
     @property
     def source(self) -> str:
@@ -648,17 +649,17 @@ def resolve_active_task(
     platform_input: dict[str, Any] | None = None,
     platform: str | None = None,
     *,
-    allow_single_session_fallback: bool = True,
+    allow_single_session_fallback: bool = False,
     allow_environment_context: bool = True,
 ) -> ActiveTask:
     """Resolve the active task from session runtime state only.
 
-    A stale session task is returned as stale. A known context identity is
-    authoritative: a missing or empty context for that identity returns no
-    task. When context identity is unavailable, single-session inference may
-    cover pull-based platform sub-agents (copilot, gemini, qoder) that don't
-    inherit the parent's session id. ≥2 files or 0 files yield
-    ActiveTask(None) — refuses to guess across windows.
+    A stale session task is returned as stale. Missing or unmatched session
+    identity does not infer ownership from the number of session files.
+    A unique developer-owned task, or an explicit ambiguous projection, may
+    still be exposed without writing a binding. Only the legacy inference from
+    one unrelated session file is opt-in; pull-based child agents use that
+    compatibility opt-in when they cannot inherit a parent session identity.
     """
     context_key = resolve_context_key(
         platform_input,
@@ -671,6 +672,9 @@ def resolve_active_task(
         active = _active_from_ref(task_ref, repo_root, "session", context_key)
         if active:
             return active
+        unbound = _resolve_unbound_task(repo_root)
+        if unbound is not None:
+            return unbound
         return ActiveTask(None, "none", context_key)
 
     if allow_single_session_fallback:
@@ -678,9 +682,9 @@ def resolve_active_task(
         if fallback is not None:
             return fallback
 
-        unbound = _resolve_unbound_task(repo_root)
-        if unbound is not None:
-            return unbound
+    unbound = _resolve_unbound_task(repo_root)
+    if unbound is not None:
+        return unbound
 
     return ActiveTask(None, "none", context_key)
 
@@ -713,8 +717,10 @@ def _resolve_single_session_fallback(repo_root: Path) -> ActiveTask | None:
 def _resolve_unbound_task(repo_root: Path) -> ActiveTask | None:
     """Expose one developer-owned task when no session pointer exists."""
     sessions_dir = _runtime_sessions_dir(repo_root)
-    if sessions_dir.is_dir() and any(sessions_dir.glob("*.json")):
-        return None
+    if sessions_dir.is_dir():
+        session_files = sorted(sessions_dir.glob("*.json"))
+        if any(_string_value((_read_json(session) or {}).get("current_task")) for session in session_files):
+            return None
 
     from .paths import get_developer, get_tasks_dir
     from .tasks import iter_active_tasks
@@ -728,11 +734,16 @@ def _resolve_unbound_task(repo_root: Path) -> ActiveTask | None:
         for task in iter_active_tasks(get_tasks_dir(repo_root))
         if task.assignee == developer and task.status in {"planning", "in_progress", "review"}
     ]
-    if len(candidates) != 1:
+    if len(candidates) == 0:
         return None
 
-    task_path = candidates[0].directory.relative_to(repo_root).as_posix()
-    return ActiveTask(task_path, "unbound", None)
+    task_paths = tuple(sorted(
+        task.directory.relative_to(repo_root).as_posix()
+        for task in candidates
+    ))
+    if len(task_paths) == 1:
+        return ActiveTask(task_paths[0], "unbound", None)
+    return ActiveTask(None, "unbound_ambiguous", None, candidate_paths=task_paths)
 
 
 def _utc_now() -> str:

package/dist/templates/trellis/scripts/common/continuation_record.py

@@ -125,7 +125,7 @@ def _file_digest(path: Path, maximum: int = MAX_EVIDENCE_BYTES) -> tuple[str, in
 
 
 def _task_source(root: Path) -> dict[str, Any]:
-    active = resolve_active_task(root)
+    active = resolve_active_task(root, allow_single_session_fallback=True)
     if not active.task_path:
         raise NoDirectCurrentTask("no_direct_current_task")
     if active.source_type == "session-fallback":

package/dist/templates/trellis/scripts/task.py

@@ -312,6 +312,11 @@ def cmd_finish(args: argparse.Namespace) -> int:
         print(colored("Task exists but no direct session is bound; run task.py start first", Colors.YELLOW))
         print(f"Task: {current}")
         return 0
+    if active.source_type == "unbound_ambiguous":
+        print(colored("Multiple tasks exist but no direct session is bound; choose one before finishing", Colors.YELLOW))
+        for candidate in active.candidate_paths:
+            print(f"Candidate: {candidate}")
+        return 0
 
     try:
         assert_task_mutation_allowed(repo_root, repo_root / current)
@@ -367,6 +372,8 @@ def cmd_current(args: argparse.Namespace) -> int:
             "source": active.source,
             "stale": active.stale,
         }
+        if active.candidate_paths:
+            payload["candidates"] = list(active.candidate_paths)
         # Only present when the read failed, so the healthy shape is unchanged.
         if read_error:
             payload["error"] = read_error
@@ -374,6 +381,12 @@ def cmd_current(args: argparse.Namespace) -> int:
         return 0 if active.task_path else 1
 
     if args.source:
+        if active.source_type == "unbound_ambiguous":
+            print("Current task: (ambiguous)")
+            print("Source: unbound_ambiguous")
+            for candidate in active.candidate_paths:
+                print(f"Candidate: {candidate}")
+            return 1
         print(f"Current task: {active.task_path or '(none)'}")
         print(f"Source: {active.source}")
         if active.stale:
@@ -384,6 +397,11 @@ def cmd_current(args: argparse.Namespace) -> int:
         print(active.task_path)
         return 0
 
+    if active.source_type == "unbound_ambiguous":
+        print("Multiple active tasks require explicit binding:")
+        for candidate in active.candidate_paths:
+            print(candidate)
+
     return 1
 
 

package/dist/templates/trellis/workflow.md

@@ -76,7 +76,7 @@ python3 ./.trellis/scripts/task.py create-pr [name] [--dry-run]
 
 > Run `python3 ./.trellis/scripts/task.py --help` to see the authoritative, up-to-date list.
 
-**Current-task mechanism**: `task.py create` creates the task directory and (when session identity is available) auto-sets the per-session active-task pointer so the planning breadcrumb fires immediately. `task.py start` writes the same pointer (idempotent if already set) and flips `task.json.status` from `planning` to `in_progress`. State is stored under `.trellis/.runtime/sessions/`. If no context key is available from hook input, `TRELLIS_CONTEXT_ID`, or a platform-native session environment variable, there is no active task and `task.py start` fails with a session identity hint. `task.py finish` deletes the current session file (status unchanged). `task.py archive <task>` writes `status=completed`, moves the directory to `archive/`, and deletes any runtime session files that still point at the archived task.
+**Current-task mechanism**: `task.py create` creates the task directory and (when session identity is available) auto-sets the per-session active-task pointer so the planning breadcrumb fires immediately. `task.py start` writes the same pointer (idempotent if already set) and flips `task.json.status` from `planning` to `in_progress`. State is stored under `.trellis/.runtime/sessions/`. If no context key is available from hook input, `TRELLIS_CONTEXT_ID`, or a platform-native session environment variable, `task.py start` fails with a session identity hint because it cannot persist a session pointer; read-only context may still project one unique developer-owned resumable task. `task.py finish` deletes the current session file (status unchanged). `task.py archive <task>` writes `status=completed`, moves the directory to `archive/`, and deletes any runtime session files that still point at the archived task.
 
 ### Workspace System
 
@@ -123,6 +123,8 @@ python3 ./.trellis/scripts/get_context.py --mode phase --step <X.Y>  # detailed
   TAG ↔ PHASE scoping:
     [workflow-state:no_task]      → no active task; before Phase 1
     [workflow-state:unbound_task] → one developer-owned task exists without a session pointer
+    [workflow-state:unbound_ambiguous] → multiple developer-owned tasks exist without a session pointer
+    [workflow-state:unbound_ambiguous-inline] → Codex inline variant of unbound_ambiguous
     [workflow-state:task_error]   → active task record is unreadable; repair it before continuing
     [workflow-state:planning]     → all of Phase 1 (status='planning')
     [workflow-state:planning-inline] → Codex inline variant of Phase 1
@@ -196,6 +198,16 @@ Complex task: ask the user if you can create a Trellis task and enter the planni
 An existing task is assigned to the current developer, but this shell has no direct Trellis session binding. Do not create a duplicate task. Continue reading and working from the existing task artifacts; before any lifecycle write or closure, run the native `task.py start <task>` command once a direct session identity is available. Never edit `.trellis/.runtime/sessions/` manually.
 [/workflow-state:unbound_task]
 
+<!-- Per-turn breadcrumb shown when multiple resumable tasks exist without a direct session binding. -->
+
+[workflow-state:unbound_ambiguous]
+Multiple active tasks belong to the current developer, but this shell has no direct Trellis session binding. Do not guess or create a duplicate task. Review the listed candidates and run `python3 ./.trellis/scripts/task.py start <task>` with the intended task once a direct session identity is available.
+[/workflow-state:unbound_ambiguous]
+
+[workflow-state:unbound_ambiguous-inline]
+Multiple active tasks belong to the current developer, but this Codex session has no direct Trellis session binding. Do not guess or create a duplicate task. Review the listed candidates and run `python3 ./.trellis/scripts/task.py start <task>` with the intended task once a direct session identity is available.
+[/workflow-state:unbound_ambiguous-inline]
+
 <!-- Per-turn breadcrumb: shown when the active task record cannot be read. -->
 
 [workflow-state:task_error]
@@ -702,6 +714,7 @@ All tag blocks live in the `## Phase Index` section above, immediately after eac
 |---|---|
 | No active task (before Phase 1) | `[workflow-state:no_task]` (after the Phase Index ASCII art) |
 | One developer-owned task without a session binding | `[workflow-state:unbound_task]` (bind before lifecycle writes) |
+| Multiple developer-owned tasks without a session binding | `[workflow-state:unbound_ambiguous]` / `[workflow-state:unbound_ambiguous-inline]` (choose and bind explicitly) |
 | Active task record unreadable | `[workflow-state:task_error]` (repair the existing task before continuing) |
 | All of Phase 1 (task created → ready for implementation) | `[workflow-state:planning]` (after Phase 1 summary) |
 | Codex inline Phase 1 | `[workflow-state:planning-inline]` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pennixrv/trellis",
-  "version": "0.6.40",
+  "version": "0.6.43",
   "description": "AI capabilities grow like ivy — Trellis provides the structure to guide them along a disciplined path",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,7 +34,7 @@
     "inquirer": "^9.3.7",
     "undici": "^6.21.0",
     "zod": "^4.4.2",
-    "@pennixrv/trellis-core": "0.6.40"
+    "@pennixrv/trellis-core": "0.6.43"
   },
   "devDependencies": {
     "@eslint/js": "^9.18.0",