@pennixrv/trellis 0.7.0-beta.24 → 0.7.0-beta.25

package/dist/migrations/manifests/0.7.0-beta.25.json

@@ -0,0 +1,9 @@
+{
+  "version": "0.7.0-beta.25",
+  "description": "Preserve identity during unbound task recovery",
+  "breaking": false,
+  "recommendMigrate": false,
+  "changelog": "Unbound task projections retain resolved direct session identity. Formal ownership retirement and claim distinguish read-only candidates from direct bindings. Recovery guidance checks identity separately and preserves planning activation gates.",
+  "migrations": [],
+  "notes": "Run trellis update after upgrading. Refresh a separately selected Marketplace workflow using its explicit immutable ref. Candidate projections remain read-only; foreign-session isolation and ownership fencing remain enforced. No identity injection or automatic task selection is required."
+}

package/dist/templates/common/commands/continue.md

@@ -8,10 +8,21 @@ Resume work on the current task — pick up at the right phase/step in `.trellis
 
 ```bash
 {{PYTHON_CMD}} ./.trellis/scripts/get_context.py
+{{PYTHON_CMD}} ./.trellis/scripts/task.py current --json
 ```
 
 Confirms: current task, git state, recent commits.
 
+Before routing by status, distinguish identity from task binding. A non-null
+`session_source` confirms available identity; only `source=session:...` confirms
+a direct task binding. For `unbound` / `unbound_ambiguous`, review existing task
+artifacts and select by the user's explicit intent. Exit code 1 for ambiguity
+does not mean identity is absent. Do not guess, duplicate tasks, invent identity,
+or edit runtime pointers. Return a planning candidate to the planning gates below;
+use native `task.py start <task>` only when its activation contract permits it.
+An eligible `analysis_only` candidate remains in planning without start.
+If `session_source` is null, report unavailable identity separately.
+
 ## Step 2: Load the Phase Index
 
 ```bash

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

@@ -694,7 +694,7 @@ 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)
+        unbound = _resolve_unbound_task(repo_root, context_key)
         if unbound is not None:
             return unbound
         return ActiveTask(None, "none", context_key)
@@ -736,8 +736,8 @@ def _resolve_single_session_fallback(repo_root: Path) -> ActiveTask | None:
     return _active_from_ref(task_ref, repo_root, "session-fallback", fallback_key)
 
 
-def _resolve_unbound_task(repo_root: Path) -> ActiveTask | None:
-    """Expose one developer-owned task when no session pointer exists."""
+def _resolve_unbound_task(repo_root: Path, context_key: str | None = None) -> ActiveTask | None:
+    """Expose read-only candidates without discarding a resolved identity."""
     sessions_dir = _runtime_sessions_dir(repo_root)
     if sessions_dir.is_dir():
         session_files = sorted(sessions_dir.glob("*.json"))
@@ -764,8 +764,8 @@ def _resolve_unbound_task(repo_root: Path) -> ActiveTask | None:
         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)
+        return ActiveTask(task_paths[0], "unbound", context_key)
+    return ActiveTask(None, "unbound_ambiguous", context_key, candidate_paths=task_paths)
 
 
 def _utc_now() -> str:
@@ -834,7 +834,7 @@ def clear_active_task(
         return ActiveTask(None, "none")
 
     previous = resolve_active_task(repo_root, platform_input, platform)
-    if not previous.task_path or not previous.context_key:
+    if previous.source_type != "session" or not previous.task_path or not previous.context_key:
         return previous
 
     context_path = _context_path(repo_root, previous.context_key)

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

@@ -10,7 +10,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
-from .active_task import clear_active_task, clear_active_task_for_context, resolve_active_task, resolve_context_key, set_active_task
+from .active_task import ActiveTask, clear_active_task, clear_active_task_for_context, resolve_active_task, resolve_context_key, set_active_task
 from .continuation_record import (
     ContinuationError,
     SAFE_ID,
@@ -83,6 +83,9 @@ def _direct_context(root: Path, require_task: bool = False) -> tuple[str, Any]:
         raise OwnershipError("session_fallback_untrusted")
     if active.context_key != context_key:
         raise OwnershipError("direct_session_identity_unstable")
+    if active.source_type in {"unbound", "unbound_ambiguous"}:
+        # Candidate paths are recovery context, never an owned session pointer.
+        active = ActiveTask(None, "none", context_key)
     if require_task and not active.task_path:
         raise OwnershipError("no_direct_current_task")
     return context_key, active
@@ -273,14 +276,14 @@ def retire(root: Path, task_id: str, handoff_id: str, core_digest: str, expected
         elif record["archive_observation"] != archive_observation:
             raise OwnershipError("archive observation does not match retirement")
 
-        active = resolve_active_task(root, allow_single_session_fallback=False)
+        _, active = _direct_context(root)
         if active.context_key != actor:
             raise OwnershipError("direct_session_identity_unstable")
         if active.task_path == record["task"]["path"]:
             clear_active_task(root)
         elif active.task_path:
             raise OwnershipError("source task pointer changed during retirement")
-        active = resolve_active_task(root, allow_single_session_fallback=False)
+        _, active = _direct_context(root)
         if active.context_key != actor or active.task_path:
             raise OwnershipError("source task retirement could not be verified; recovery_required")
         record["previous_event_digest"] = record["integrity"]["record_digest"]
@@ -334,7 +337,7 @@ def claim(root: Path, task_id: str, task_path: str, handoff_id: str, core_digest
                 bound = set_active_task(record["task"]["path"], root)
                 if not bound:
                     raise OwnershipError("target task binding failed; recovery_required")
-                active = resolve_active_task(root, allow_single_session_fallback=False)
+                _, active = _direct_context(root)
             if active.context_key != actor or active.task_path != record["task"]["path"]:
                 raise OwnershipError("target task binding could not be verified; recovery_required")
             record["previous_event_digest"] = record["integrity"]["record_digest"]
@@ -361,7 +364,7 @@ def claim(root: Path, task_id: str, task_path: str, handoff_id: str, core_digest
         bound = set_active_task(task["path"], root)
         if not bound:
             raise OwnershipError("target task binding failed; recovery_required")
-        active = resolve_active_task(root, allow_single_session_fallback=False)
+        _, active = _direct_context(root)
         if active.context_key != actor or active.task_path != task["path"]:
             raise OwnershipError("target task binding could not be verified; recovery_required")
         record["previous_event_digest"] = record["integrity"]["record_digest"]

package/dist/templates/trellis/workflow.md

@@ -200,17 +200,17 @@ Complex task: ask the user if you can create a Trellis task and enter the planni
 <!-- Per-turn breadcrumb: shown when one resumable task exists without a direct session binding. -->
 
 [workflow-state:unbound_task]
-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.
+An existing developer-owned task has no direct session binding. Inspect native `task.py current --json`: a non-null `session_source` means direct identity is already available; an unbound source still means no task binding. Select the existing task from the user's explicit intent; do not guess or create a duplicate. Resume its planning/status gates first. Run native `task.py start <task>` only when its activation contract permits it, after the Planning Seal and implementation authorization for a planning change-bearing task. An eligible `analysis_only` task stays in planning without start. If identity is absent, report that separately; never invent an identity or edit runtime pointers.
 [/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.
+Multiple developer-owned tasks have no direct session binding. Inspect native `task.py current --json`: a non-null `session_source` means direct identity is already available; an unbound source still means no task binding. Select the existing task from the user's explicit intent; do not guess or create a duplicate. Resume its planning/status gates first. Run native `task.py start <task>` only when its activation contract permits it, after the Planning Seal and implementation authorization for a planning change-bearing task. An eligible `analysis_only` task stays in planning without start. If identity is absent, report that separately; never invent an identity or edit runtime pointers.
 [/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.
+Multiple developer-owned tasks have no direct session binding. Inspect native `task.py current --json`: a non-null `session_source` means direct identity is already available; an unbound source still means no task binding. Select the existing task from the user's explicit intent; do not guess or create a duplicate. Resume its planning/status gates first. Run native `task.py start <task>` only when its activation contract permits it, after the Planning Seal and implementation authorization for a planning change-bearing task. An eligible `analysis_only` task stays in planning without start. If identity is absent, report that separately; never invent an identity or edit runtime pointers.
 [/workflow-state:unbound_ambiguous-inline]
 
 <!-- Per-turn breadcrumb: shown when the active task record cannot be read. -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pennixrv/trellis",
-  "version": "0.7.0-beta.24",
+  "version": "0.7.0-beta.25",
   "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.7.0-beta.24"
+    "@pennixrv/trellis-core": "0.7.0-beta.25"
   },
   "devDependencies": {
     "@eslint/js": "^9.18.0",