@@ -1495,16 +1495,18 @@ Post-turn accounting protocol:
   workspace cannot produce that local receipt. For originless Git, the checkout
   root must equal the registered project root; nested repositories, linked
   worktrees, invalid/empty origins and failed Git config reads cannot fall back.
-- `quota should-run` also recognizes explicitly declared local material work:
-  `same_agent_non_delivery`, a non-code task domain, no task repository, and all
-  relative Todo write scopes contained by absolute Goal grants rooted at the
-  observed local project. These peer tasks keep their write scopes and use the
-  existing local Goal delivery snapshot instead of requiring a Git worktree.
-  Exact paths and recursive directory grants qualify; complex absolute globs
-  do not. Outside-root work receives a return-to-Goal diagnostic. Code work,
-  foreign repositories, undeclared contracts and explicit isolation policies
-  retain their existing guards. This changes local peer material admission,
-  not authorization, claim/lease rules or causal settlement requirements.
+- `quota should-run` reuses that registered `local_goal` identity for local
+  tasks by default. Declaring write scopes does not turn local work into a Git
+  edit or require a particular task domain or continuation marker. An explicit
+  task repository and owner isolation requirements keep their existing guards.
+  Relative Goal scopes keep their existing matching semantics; absolute grants
+  under the registered root are projected into the same relative view, including
+  existing glob patterns. The existing boundary guard alone checks coverage.
+  Caller cwd does not rebase the declared targets or itself block local work.
+  If actual delivery is produced in the Goal project from another cwd, use
+  `refresh-state --delivery-workspace-path <Goal-project>`; settlement consumes
+  that recorded local workspace without requiring a cwd move. This changes local
+  task admission, not grants, claim/lease or causal settlement requirements.
 - `todo complete --evidence <pointer>` can record a validated local artifact.
   `--result-file` additionally requires approved Goal acceptance criteria bound
   to that Todo. A standalone Todo validator does not establish Goal acceptance;
 
@@ -323,12 +323,12 @@ def _peer_work_requires_isolated_workspace(
     agent_todo_summary: dict[str, Any] | None,
     *,
     selected_todo: dict[str, Any] | None = None,
-    local_write_scope_admitted: bool = False,
+    local_goal_workspace: bool = False,
 ) -> bool:
     explicit = workspace_guard_policy.get("peer_independent_worktree_required")
     if explicit is not None:
         return explicit is True
-    if local_write_scope_admitted:
+    if local_goal_workspace:
         return False
     candidate = (
         selected_todo
@@ -347,19 +347,14 @@ def _peer_work_requires_isolated_workspace(
     )
 
 
-def observe_goal_local_write_scopes(
+def observe_goal_local_workspace(
     goal: dict[str, Any],
     selected_todo: dict[str, Any] | None,
     allowed_write_scopes: list[str] | None = None,
 ) -> dict[str, Any]:
-    """Read physical Goal identity once; typed work requirements own admission."""
-    empty = {"admitted": False, "allowed_write_scopes": []}
-    if (
-        not selected_todo
-        or selected_todo.get("task_repository")
-        or selected_todo.get("continuation_policy") != "same_agent_non_delivery"
-        or not selected_todo.get("required_write_scopes")
-    ):
+    """Reuse the registered workspace identity and project its existing grants."""
+    empty: dict[str, Any] = {}
+    if not selected_todo or selected_todo.get("task_repository"):
         return empty
     repo = goal.get("repo") or goal.get("project") or goal.get("root")
     goal_id = goal.get("goal_id") or goal.get("id")
@@ -378,11 +373,11 @@ def observe_goal_local_write_scopes(
     scopes = allowed_write_scopes if allowed_write_scopes is not None else raw_scopes
     if not isinstance(scopes, list) or any(not isinstance(scope, str) for scope in scopes):
         return empty
-    from ..quota.settlement_workspace_causality import project_goal_local_write_scopes
+    from ..quota.settlement_workspace_causality import project_goal_write_scopes
 
     # Physical identity is resolved above. Scope authority stays relative to the
     # registered spelling, including an explicit symlink alias of that root.
-    return project_goal_local_write_scopes(str(root), selected_todo, scopes)
+    return {"workspace": snapshot, **project_goal_write_scopes(str(root), scopes)}
 
 
 def build_agent_workspace_guard(
@@ -392,7 +387,7 @@ def build_agent_workspace_guard(
     agent_todo_summary: dict[str, Any] | None = None,
     selected_todo: dict[str, Any] | None = None,
     current_path: Path | None = None,
-    local_write_scopes: dict[str, Any] | None = None,
+    local_workspace: dict[str, Any] | None = None,
 ) -> dict[str, Any] | None:
     if not isinstance(agent_identity, dict):
         return None
@@ -410,41 +405,18 @@ def build_agent_workspace_guard(
         else next(iter(_peer_candidate_items(agent_todo_summary)), {})
     )
     local = (
-        local_write_scopes
-        if local_write_scopes is not None
-        else observe_goal_local_write_scopes(goal, candidate)
+        local_workspace
+        if local_workspace is not None
+        else observe_goal_local_workspace(goal, candidate)
     )
-    root = goal.get("repo") or goal.get("project") or goal.get("root")
-    local_admitted = local.get("admitted") is True
-    if local_admitted and root:
-        current = capture_delivery_workspace(
-            current_path,
-            local_goal_id=str(goal.get("goal_id") or goal.get("id")),
-            local_project_root=Path(str(root)),
-        )
-        local_admitted = bool(current and current.get("identity_kind") == "local_goal")
-        if (
-            not local_admitted
-            and workspace_guard_policy.get("peer_independent_worktree_required")
-            is not False
-        ):
-            return {
-                "schema_version": AGENT_WORKSPACE_GUARD_SCHEMA_VERSION,
-                "source": "quota.should-run",
-                "action": local["workspace_repair_action"],
-                "current_workspace": "foreign_workspace",
-                "required_workspace": "local_goal_workspace",
-                "blocks_delivery": True,
-                "agent_id": agent_identity.get("agent_id"),
-                "repository_source": "goal.repo",
-                "reason": "declared local writes must run from the registered Goal workspace",
-                "required_action": "return to the registered Goal project and rerun quota should-run before local writes",
-            }
+    # Local declarations are relative to the registered Goal target, not the
+    # caller cwd. Causal accounting still names the actual delivery workspace.
+    local_admitted = (local.get("workspace") or {}).get("identity_kind") == "local_goal"
     if not _peer_work_requires_isolated_workspace(
         workspace_guard_policy,
         agent_todo_summary,
         selected_todo=selected_todo,
-        local_write_scope_admitted=local_admitted,
+        local_goal_workspace=local_admitted,
     ):
         return None
     task_repository = normalize_todo_task_repository(candidate.get("task_repository"))
 
@@ -182,7 +182,6 @@ def build_boundary_projection_repair_hint(
     candidate_should_run: bool,
     capability_gate: dict[str, Any] | None = None,
     selected_todo: dict[str, Any] | None = None,
-    local_write_scopes: dict[str, Any] | None = None,
 ) -> dict[str, Any] | None:
     if not candidate_should_run or not isinstance(agent_todo_summary, dict):
         return None
@@ -220,12 +219,6 @@ def build_boundary_projection_repair_hint(
         return None
     boundary = goal_boundary if isinstance(goal_boundary, dict) else {}
     allowed_scopes = normalize_required_write_scopes(boundary.get("write_scope"))
-    if local_write_scopes:
-        allowed_scopes.extend(
-            normalize_required_write_scopes(
-                local_write_scopes.get("allowed_write_scopes")
-            )
-        )
     missing_scopes = [
         scope
         for scope in required_scopes
 
@@ -32,25 +32,22 @@
 DELIVERY_WORKSPACE_REQUIREMENTS = frozenset({"required", "not_required", "unknown"})
 
 
-def project_goal_local_write_scopes(
+def project_goal_write_scopes(
     project_root: str,
-    todo: Mapping[str, Any],
     allowed_scopes: list[str],
 ) -> dict[str, Any]:
     """Adapt observed local-root facts to the existing typed work owner."""
     result = _runtime_result(
-        "goal_local_write_scopes",
+        "goal_write_scopes",
         project_root=project_root,
-        todo=dict(todo),
         allowed_scopes=allowed_scopes,
-    ).get("local_write_scopes")
+    ).get("write_scope_projection")
     if (
         not isinstance(result, Mapping)
-        or not isinstance(result.get("admitted"), bool)
         or not isinstance(result.get("allowed_write_scopes"), list)
         or any(not isinstance(scope, str) for scope in result["allowed_write_scopes"])
     ):
-        raise RuntimeError("TypeScript local write scope result shape mismatch")
+        raise RuntimeError("TypeScript Goal write scope projection shape mismatch")
     return dict(result)
 
 
 
@@ -9,7 +9,7 @@ import {
 } from "../coordination/coordination_state_contract.generated.ts";
 import { EffectRuntimeRequestError } from "../effect_runtime_errors.ts";
 import { requireJsonObject as requiredObject } from "../runtime_decode.ts";
-import { projectGoalLocalWriteScopes } from "../todos/work_requirements.ts";
+import { projectGoalWriteScopes } from "../todos/work_requirements.ts";
 
 export const DELIVERY_WORKSPACE_CAUSALITY_SCHEMA_VERSION =
   DELIVERY_WORKSPACE_CAUSALITY_SCHEMA;
@@ -39,7 +39,7 @@ export interface DeliveryWorkspaceCausality extends JsonObject {
 }
 
 type DeliveryWorkspaceCausalityOperation =
-  | "goal_local_write_scopes"
+  | "goal_write_scopes"
   | "classify"
   | "normalize"
   | "event_fields"
@@ -142,7 +142,7 @@ function operation(value: unknown): DeliveryWorkspaceCausalityOperation {
     value === "classify" || value === "normalize" ||
     value === "event_fields" || value === "missing_workspace" ||
     value === "settlement_requirement" ||
-    value === "from_event" || value === "goal_local_write_scopes"
+    value === "from_event" || value === "goal_write_scopes"
   ) return value;
   throw new EffectRuntimeRequestError("delivery workspace causality operation is unsupported");
 }
@@ -351,8 +351,8 @@ export function evaluateDeliveryWorkspaceCausality(value: unknown): JsonObject {
     request.expected_todo_id,
     "expected_todo_id",
   );
-  if (selectedOperation === "goal_local_write_scopes") {
-    return result({ local_write_scopes: projectGoalLocalWriteScopes(request) });
+  if (selectedOperation === "goal_write_scopes") {
+    return result({ write_scope_projection: projectGoalWriteScopes(request) });
   }
   if (selectedOperation === "classify") {
     return result({
 
@@ -16,7 +16,7 @@
 )
 from ..agents.workspace_guard import (
     build_agent_workspace_guard,
-    observe_goal_local_write_scopes,
+    observe_goal_local_workspace,
 )
 from ..quota.decision_summary import (
     quota_plan_items as _quota_plan_items,
@@ -117,7 +117,7 @@ def _apply_selected_todo_guards(
             )
             route = _resolve_quota_should_run_route(prepared)
     workspace_guard = None
-    local_write_scopes = observe_goal_local_write_scopes(
+    local_workspace = observe_goal_local_workspace(
         prepared.item, selected_todo, prepared.goal_boundary.get("write_scope", [])
     )
     if not prepared.inbox_priority_due:
@@ -127,15 +127,17 @@ def _apply_selected_todo_guards(
             agent_todo_summary=prepared.agent_todo_summary,
             selected_todo=selected_todo,
             current_path=workspace_path,
-            local_write_scopes=local_write_scopes,
+            local_workspace=local_workspace,
         )
     boundary_projection_repair = build_boundary_projection_repair_hint(
-        prepared.goal_boundary,
+        {**prepared.goal_boundary, "write_scope": [
+            *prepared.goal_boundary.get("write_scope", []),
+            *local_workspace.get("allowed_write_scopes", []),
+        ]},
         prepared.agent_todo_summary,
         candidate_should_run=bool(route.should_run),
         capability_gate=prepared.capability_gate,
         selected_todo=selected_todo,
-        local_write_scopes=local_write_scopes,
     )
     if not workspace_guard and not boundary_projection_repair:
         return route
 
@@ -2,44 +2,29 @@
  * These validate requirements, never grant capabilities or write authority. */
 import type { JsonObject } from "../effect_program.ts";
 import { EffectRuntimeRequestError } from "../effect_runtime_errors.ts";
-import { optionalNonEmptyString, requireJsonObject, requireStringArray } from "../runtime_decode.ts";
+import { optionalNonEmptyString, requireStringArray } from "../runtime_decode.ts";
 import { compactPythonWhitespace, stripPythonWhitespace } from "../coordination/todo_agents.ts";
 import { normalizeWriteScopes } from "../work_items/task_lease_acquire.ts";
 import { isAbsolute, resolve, sep } from "node:path";
 
-/** A Goal-local declaration keeps relative Todo scopes. Absolute Goal grants
+/** Goal scope projection preserves existing relative scopes. Absolute grants
  * are projected only against the observed local Goal root, never by suffix or
  * against a different repository. This is a read projection, not a grant. */
-export function projectGoalLocalWriteScopes(value: JsonObject): JsonObject {
+export function projectGoalWriteScopes(value: JsonObject): JsonObject {
   const root = optionalNonEmptyString(value.project_root, "project_root");
-  const empty = { admitted: false, allowed_write_scopes: [] };
-  if (!root || !isAbsolute(root) || value.todo == null) return empty;
-  const todo = requireJsonObject(value.todo, "local write Todo");
-  if (todo.task_repository || !todo.task_domain || todo.task_domain === "code" ||
-    todo.continuation_policy !== "same_agent_non_delivery") return empty;
-  const required = requireStringArray(todo.required_write_scopes ?? [], "required_write_scopes");
-  if (!required.length || required.some(scope => !normalizeWriteScopes([scope]).length ||
-    scope.includes("\\") || scope.split("/").includes("."))) return empty;
+  if (!root || !isAbsolute(root)) return { allowed_write_scopes: [] };
   const prefix = resolve(root).replaceAll(sep, "/").replace(/\/+$/, "") + "/";
   const allowed: string[] = [];
   for (const raw of requireStringArray(value.allowed_scopes ?? [], "allowed_scopes")) {
     const scope = raw.replaceAll(sep, "/");
-    // Do not resolve a grant's dot segments: that would change its authority.
-    if (!scope.startsWith(prefix) || scope.includes("\\") || scope.split("/").some(part => part === "." || part === "..")) continue;
-    const relative = scope.slice(prefix.length);
-    if (!normalizeWriteScopes([relative]).length) continue;
-    // Exact paths and recursive directory grants have unambiguous containment.
-    // Complex glob grants stay on their existing path rather than widening here.
-    const base = relative.endsWith("/**") ? relative.slice(0, -3) : relative;
-    if (/[\[*?]/.test(base)) continue;
-    if (!allowed.includes(relative)) allowed.push(relative);
+    // Only strip the registered root. Preserve the existing relative/glob
+    // semantics; the boundary guard, not this projection, checks coverage.
+    const relative = isAbsolute(scope)
+      ? (scope.startsWith(prefix) ? scope.slice(prefix.length) : "")
+      : scope;
+    if (normalizeWriteScopes([relative]).length && !allowed.includes(relative)) allowed.push(relative);
   }
-  return {
-    admitted: required.every(scope => allowed.some(grant =>
-      scope === grant || (grant.endsWith("/**") && scope.startsWith(grant.slice(0, -2))))),
-    allowed_write_scopes: allowed,
-    workspace_repair_action: "move_to_goal_workspace",
-  };
+  return { allowed_write_scopes: allowed };
 }
 
 function optionalText(value: unknown, label: string): string | null {
 
@@ -1493,7 +1493,7 @@ def _build_interaction_cli_channel(
             "refresh": (
                 "delivery_workspace; otherwise --delivery-workspace-path"
                 if selected_todo.get("task_repository")
-                else "registered local Goal workspace; follow the current workspace guard and repository rules"
+                else "registered local Goal target; when caller cwd differs, refresh with --delivery-workspace-path for the actual target; spend uses the recorded delivery workspace"
             ),
             "spend": "recorded_delivery_workspace",
             "mismatch": "fail_closed",