ms-tau-sdk 2.0.26.dev77__tar.gz → 2.0.26.dev78__tar.gz

{ms_tau_sdk-2.0.26.dev77 → ms_tau_sdk-2.0.26.dev78}/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## Unreleased
 
+- **The deployed Agent reads its resources only from `.tau/` by default (ADR 0025).** Tau, a
+  coding-agent harness, also read the repository's development instructions as the Agent's: the
+  root `AGENTS.md` and every `AGENTS.md` above the workspace were injected as project
+  instructions, and since 2.0.15 every skill under `.agents/skills`, among them the `ms_tau_sdk`,
+  `mainsequence` and repository development bundles, was listed as one of the Agent's skills,
+  expandable from chat with `/skill:<name>` and served by the skill-scoped `read`. The runtime now
+  reads skills from `.tau/skills`, prompt templates from `.tau/prompts` and project instructions
+  from `.tau/AGENTS.md`; `.agents/skills`, `.agents/prompts` and every `AGENTS.md` outside `.tau`
+  are not read. The new `TAU_INCLUDE_DEVELOPMENT_RESOURCES` setting (default `false`) restores
+  Tau's whole-repository reading for an Agent that is a coding agent over its own repository; like
+  the two exclusion settings it is process-wide and applies to managed and local sessions. The
+  interception of Tau's `AGENTS.md` discovery is locked to `tau-ai==0.4.2`, like the provider
+  patch of ADR 0016, and another version fails session construction. The selected system prompt
+  files, context files and skills, and Tau's resource diagnostics, such as a skill overriding
+  another or an `AGENTS.md` left out, are logged as `runtime.project_resources.*` and shown in
+  agent inspection under `resources`. **Migration:** a repository whose Agent used skills under
+  `.agents/skills` at runtime moves them directly into `.tau/skills` and, when it publishes them
+  with the mainsequence SDK's `skills_extension`, points the publisher at `.tau/skills`; the
+  publisher's folder rules then apply to the whole folder, and a skill folder cannot share its
+  name with a group folder. Instructions for the Agent that lived in the root `AGENTS.md` move to
+  `.tau/AGENTS.md`. `ms-tau skills sync` and the development workflow are unchanged.
 - Move the advisory `design-agent-icons-and-motion` skill and its worked MetaTables visual
   example into the SDK-owned skill bundle. `ms-tau skills sync` installs both under
   `.agents/skills/ms_tau_sdk/`; project artwork remains in its owning repository. No runtime

{ms_tau_sdk-2.0.26.dev77 → ms_tau_sdk-2.0.26.dev78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ms-tau-sdk
-Version: 2.0.26.dev77
+Version: 2.0.26.dev78
 Summary: Workspace-bound Tau application primitives for Main Sequence projects
 Project-URL: Changelog, https://github.com/mainsequence-sdk/ms-tau-sdk/blob/development/CHANGELOG.md
 Project-URL: Documentation, https://github.com/mainsequence-sdk/ms-tau-sdk/tree/development/docs
@@ -119,7 +119,9 @@ uv run ms-tau skills sync --path .
 ```
 
 This explicit command owns only `.agents/skills/ms_tau_sdk/`; package installation and runtime
-startup never modify the repository automatically. The bundle includes
+startup never modify the repository automatically. These skills guide the coding agent that works
+on the repository; the deployed Agent reads its own resources from `.tau/` only and never sees
+them. The bundle includes
 [`design-agent-icons-and-motion`](src/ms_tau_sdk/agent_skills/design-agent-icons-and-motion/SKILL.md):
 advisory composition and animation guidance with a self-contained MetaTables visual example.
 Each agent's artwork and build files remain in its owning project.
@@ -268,12 +270,20 @@ defaults and install project-specific tools through the normal `.tau/` structure
 your-project/
 ├── .tau/
 │   ├── SYSTEM.md
+│   ├── AGENTS.md
 │   ├── settings.json
+│   ├── skills/
 │   └── extensions/
 ├── pyproject.toml
 └── uv.lock
 ```
 
+`.tau/` is the only directory the deployed Agent reads by default. The repository root's
+`AGENTS.md` and the `.agents/` skills are for the coding agents that develop the repository and do
+not reach the deployed Agent, unless the Agent is itself a coding agent over its repository and
+the host sets `TAU_INCLUDE_DEVELOPMENT_RESOURCES=true`. See
+[ADR 0025](docs/adrs/0025-runtime-resources-only-from-tau.md).
+
 Extensions run as project code in the same process and trust boundary as the rest of the
 repository. Optional capabilities such as general web access belong in a project extension; they
 are not bundled into the SDK. Main Sequence transport and protocol behavior remains SDK-owned.

{ms_tau_sdk-2.0.26.dev77 → ms_tau_sdk-2.0.26.dev78}/README.md

@@ -85,7 +85,9 @@ uv run ms-tau skills sync --path .
 ```
 
 This explicit command owns only `.agents/skills/ms_tau_sdk/`; package installation and runtime
-startup never modify the repository automatically. The bundle includes
+startup never modify the repository automatically. These skills guide the coding agent that works
+on the repository; the deployed Agent reads its own resources from `.tau/` only and never sees
+them. The bundle includes
 [`design-agent-icons-and-motion`](src/ms_tau_sdk/agent_skills/design-agent-icons-and-motion/SKILL.md):
 advisory composition and animation guidance with a self-contained MetaTables visual example.
 Each agent's artwork and build files remain in its owning project.
@@ -234,12 +236,20 @@ defaults and install project-specific tools through the normal `.tau/` structure
 your-project/
 ├── .tau/
 │   ├── SYSTEM.md
+│   ├── AGENTS.md
 │   ├── settings.json
+│   ├── skills/
 │   └── extensions/
 ├── pyproject.toml
 └── uv.lock
 ```
 
+`.tau/` is the only directory the deployed Agent reads by default. The repository root's
+`AGENTS.md` and the `.agents/` skills are for the coding agents that develop the repository and do
+not reach the deployed Agent, unless the Agent is itself a coding agent over its repository and
+the host sets `TAU_INCLUDE_DEVELOPMENT_RESOURCES=true`. See
+[ADR 0025](docs/adrs/0025-runtime-resources-only-from-tau.md).
+
 Extensions run as project code in the same process and trust boundary as the rest of the
 repository. Optional capabilities such as general web access belong in a project extension; they
 are not bundled into the SDK. Main Sequence transport and protocol behavior remains SDK-owned.

{ms_tau_sdk-2.0.26.dev77 → ms_tau_sdk-2.0.26.dev78}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ms-tau-sdk"
-version = "2.0.26.dev77"
+version = "2.0.26.dev78"
 description = "Workspace-bound Tau application primitives for Main Sequence projects"
 readme = "README.md"
 requires-python = ">=3.13"

{ms_tau_sdk-2.0.26.dev77 → ms_tau_sdk-2.0.26.dev78}/src/ms_tau_sdk/agent_skills/tau_project_customization/SKILL.md

@@ -15,24 +15,39 @@ The workspace `.tau/` directory is the project behavior boundary:
 
 ```text
 .tau/
-├── SYSTEM.md
+├── SYSTEM.md            replaces the packaged system prompt
+├── APPEND_SYSTEM.md     appended to the system prompt
+├── AGENTS.md            project instructions for the deployed Agent
 ├── prompts/
 ├── skills/
 └── extensions/
 ```
 
 Creating `.tau/SYSTEM.md` replaces the packaged default general system instructions. There is no
-second SDK-specific prompt override or companion append file. Other resources follow the TAU
-version pinned by the installed SDK.
-
-`.agents/skills/ms_tau_sdk/` is different: it contains managed development instructions for coding
-agents working on the repository. It is not the runtime's `.tau` behavior and must not be used as
-application configuration.
-
-Tau reads skills in `.tau/skills/` and `.agents/skills/` at any depth: a folder without a
-`SKILL.md` groups skills, such as `.agents/skills/mcp_tools/<skill>/SKILL.md`, the folder an
-application can publish with the mainsequence SDK's skills publisher. The managed skills in
-`.agents/skills/ms_tau_sdk/` are read too.
+SDK-specific prompt setting; Tau's own `APPEND_SYSTEM.md` and `AGENTS.md` under `.tau/` are the
+other prompt resources. Other resources follow the TAU version pinned by the installed SDK.
+
+By default the deployed Agent reads `.tau/` and nothing else in the repository. The root
+`AGENTS.md` and `.agents/` hold instructions for coding agents working on the repository, you
+among them: `.agents/skills/ms_tau_sdk/` is this SDK's managed development bundle,
+`.agents/skills/mainsequence/` the platform SDK's, and the repository adds its own. None of it is
+runtime behavior, none of it reaches the Agent, and none of it may be used as application
+configuration. Put instructions meant for the Agent in `.tau/AGENTS.md`, `.tau/APPEND_SYSTEM.md`
+or `.tau/SYSTEM.md`. Only an Agent that is itself a coding agent over its repository sets
+`TAU_INCLUDE_DEVELOPMENT_RESOURCES=true`, which reads the root `AGENTS.md` and `.agents/` as well.
+
+Tau reads the Agent's skills in `.tau/skills/` at any depth: a folder with a `SKILL.md` is a skill,
+named after its folder; a folder without one groups skills, such as
+`.tau/skills/<group>/<skill>/SKILL.md`. When the application also publishes the Agent's usage skills
+to other agents with the mainsequence SDK's `skills_extension`, point the publisher at `.tau/skills`
+itself: the Agent's skills and the published skills are one set. Do not publish a group folder
+inside it to keep some skills private; instructions other agents may not see belong in
+`.tau/SYSTEM.md` or `.tau/AGENTS.md`. The publisher's rules then hold for the whole folder:
+lowercase letters, digits and single hyphens in every skill and group folder name; every folder a
+skill or a non-empty group; frontmatter `name` equal to the folder name; leaf folder names unique,
+because Tau names a skill by its folder. A group folder prefixes the published `skill://` URIs, so
+a pack that was published from its own folder moves its skills directly into `.tau/skills` to keep
+its URIs. Development skills stay in `.agents/skills` and are never published.
 
 ## Agent artwork
 
@@ -62,12 +77,14 @@ tools are project choices and are not part of the base SDK.
 
 ## Runtime tool composition
 
-Two independent process settings select the host-provided tools. Both default to `false`:
+Three independent process settings select the host-provided tools and the reading scope. All
+default to `false`:
 
 | Setting | Effect when `true` |
 | --- | --- |
 | `TAU_EXCLUDE_BASE_TOOLS` | Replace Tau's `read`, `write`, `edit`, and `bash` with a skill-scoped `read`. |
 | `TAU_EXCLUDE_MAINSEQUENCE_MCP` | Skip Main Sequence MCP connection, tools, resources, and resource prompt. |
+| `TAU_INCLUDE_DEVELOPMENT_RESOURCES` | Read the repository as a coding harness: the root `AGENTS.md`, every `AGENTS.md` above the workspace, `.agents/AGENTS.md`, `.agents/skills` and `.agents/prompts`, beside `.tau`. |
 
 Set them in `harness_agent.spec.env_vars` in a managed repository workflow, in the process
 environment for local `ms-tau`, or through explicit `TauSDKSettings` fields in a Python host. They
@@ -116,7 +133,7 @@ A declared application can publish Agent Skills through the MCP Skills extension
 mainsequence SDK's skills publisher does. The Agent lists them with `<name>__list_resources` and
 reads one file with `<name>__read_resource`; a skill file is returned only when its bytes match the
 size and SHA-256 digest the skill lists. Published skills stay the application's: they are not
-project skills under `.tau/skills/`, and fields such as `allowed-tools` grant nothing. With the
+added to this Agent's skills under `.tau/skills/`, and fields such as `allowed-tools` grant nothing. With the
 coding tools, a model that follows a published skill can run commands; set
 `TAU_EXCLUDE_BASE_TOOLS=true` when that must not happen.
 

{ms_tau_sdk-2.0.26.dev77 → ms_tau_sdk-2.0.26.dev78}/src/ms_tau_sdk/agent_skills/tau_repository_integration/SKILL.md

@@ -22,6 +22,8 @@ uv run ms-tau skills sync --path .
 
 This command atomically owns only `.agents/skills/ms_tau_sdk/`. Do not copy these files manually,
 edit the managed copies, or make installation and runtime startup synchronize them implicitly.
+These are development instructions for coding agents; the Agent the repository deploys reads its
+resources from `.tau/` only and never sees `.agents/` or the root `AGENTS.md`.
 
 ## Service entry points
 

ms_tau_sdk-2.0.26.dev78/src/ms_tau_sdk/resources/context_compat.py

@@ -0,0 +1,107 @@
+"""Version-locked interception of Tau's project instruction discovery (ADR 0025).
+
+Tau is a coding-agent harness. It reads the repository root's ``AGENTS.md``, every ``AGENTS.md``
+between the project root and the workspace, and ``.agents/AGENTS.md`` as project instructions,
+the way Codex and Claude Code do. In a repository that deploys an Agent those files instruct the
+coding agents that develop the repository, not the Agent. ``tau-ai==0.4.2`` computes the ancestor
+files from the workspace directly, so the SDK's ``TauPaths`` cannot redirect them, and no session
+option or extension hook removes a discovered file.
+
+This module wraps the discovery function where ``tau_coding.session`` calls it, on load and on
+reload. For resource paths whose ``TauPaths`` declare that they do not read the development
+resources, it keeps only the files under the workspace ``.tau`` directory; for every other caller
+it returns Tau's result unchanged. Tau's own reading, diagnostics and de-duplication are reused.
+Like the provider patch of ADR 0016, the wrapper is locked to the exact Tau version it was
+reviewed against: an unverified wrapper could let development instructions reach a deployed Agent
+silently.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+from pathlib import Path
+from typing import Any
+
+from tau_coding import context as tau_context
+from tau_coding import session as tau_session
+from tau_coding.resources import ResourceDiagnostic, TauResourcePaths
+from tau_coding.system_prompt import ProjectContextFile
+
+from ms_tau_sdk.errors import ConfigurationError
+
+AFFECTED_TAU_AI_VERSION = "0.4.2"
+_PATCH_MARKER = "__ms_tau_sdk_project_context_filter__"
+# The attribute a `TauPaths` sets to `False` to keep project instructions to `.tau`.
+READS_DEVELOPMENT_RESOURCES = "reads_development_resources"
+EXCLUDED_CONTEXT_MESSAGE = (
+    "not read: an AGENTS.md outside .tau instructs the coding agents that develop the "
+    "repository, not the Agent; TAU_INCLUDE_DEVELOPMENT_RESOURCES reads it (ADR 0025)"
+)
+
+
+def install_project_context_filter() -> None:
+    """Install the reviewed Tau 0.4.2 project instruction filter exactly once.
+
+    A Tau upgrade must review and either remove or explicitly retarget this private-boundary
+    wrapper. Failing session construction is safer than applying it to another version unseen.
+    """
+
+    installed_version = version("tau-ai")
+    if installed_version != AFFECTED_TAU_AI_VERSION:
+        raise ConfigurationError(
+            "The ms-tau-sdk project instruction filter only supports "
+            f"tau-ai=={AFFECTED_TAU_AI_VERSION}; found {installed_version}. Review "
+            "tau_coding.context.discover_project_context_with_diagnostics and its use in "
+            "tau_coding.session before changing the pin (ADR 0025)."
+        )
+
+    session_module: Any = tau_session
+    current = session_module.discover_project_context_with_diagnostics
+    if getattr(current, _PATCH_MARKER, False):
+        return
+    if current is not tau_context.discover_project_context_with_diagnostics:
+        raise ConfigurationError(
+            "Tau project context discovery changed; compatibility review required (ADR 0025)"
+        )
+
+    original = current
+
+    def filtered(
+        paths: TauResourcePaths | None = None,
+    ) -> tuple[tuple[ProjectContextFile, ...], tuple[ResourceDiagnostic, ...]]:
+        context_files, diagnostics = original(paths)
+        if (
+            paths is None
+            or paths.cwd is None
+            or getattr(paths.paths, READS_DEVELOPMENT_RESOURCES, True)
+        ):
+            return context_files, diagnostics
+        # Tau resolves every discovered path; compare against the resolved `.tau` directory.
+        tau_dir = (paths.cwd / ".tau").expanduser().resolve()
+        kept: list[ProjectContextFile] = []
+        excluded: list[ResourceDiagnostic] = []
+        for context_file in context_files:
+            path = Path(context_file.path)
+            if path.is_relative_to(tau_dir):
+                kept.append(context_file)
+            else:
+                excluded.append(
+                    ResourceDiagnostic(
+                        kind="context",
+                        path=path,
+                        severity="info",
+                        message=EXCLUDED_CONTEXT_MESSAGE,
+                    )
+                )
+        return tuple(kept), (*diagnostics, *excluded)
+
+    setattr(filtered, _PATCH_MARKER, True)
+    session_module.discover_project_context_with_diagnostics = filtered
+
+
+__all__ = [
+    "AFFECTED_TAU_AI_VERSION",
+    "EXCLUDED_CONTEXT_MESSAGE",
+    "READS_DEVELOPMENT_RESOURCES",
+    "install_project_context_filter",
+]

ms_tau_sdk-2.0.26.dev78/src/ms_tau_sdk/resources/loader.py

@@ -0,0 +1,120 @@
+"""Packaged Tau resource paths with project-native override semantics."""
+
+from __future__ import annotations
+
+from collections.abc import Generator, Iterator
+from importlib.resources import files
+from pathlib import Path
+from typing import ClassVar, Self
+
+from tau_coding.paths import TauPaths
+from tau_coding.resources import TauResourcePaths
+
+from ms_tau_sdk.resources.context_compat import install_project_context_filter
+
+
+def resource_root() -> Path:
+    return Path(str(files("ms_tau_sdk.resources")))
+
+
+class _SkillsDir(Path):
+    """A skills directory whose listing also holds the skills inside its group folders.
+
+    Tau reads the folders directly in a skills directory, so the skills in a folder without a
+    `SKILL.md`, such as `.tau/skills/<group>/<skill>/SKILL.md`, were skipped. Listing them
+    beside the direct entries lets Tau read, index, reload and serve them like any other skill.
+    """
+
+    def iterdir(self) -> Generator[Self]:
+        for entry in sorted(Path(self).iterdir()):
+            yield self.with_segments(entry)
+            if _is_group(entry):
+                yield from map(self.with_segments, _skill_folders(entry))
+
+
+def _is_group(folder: Path) -> bool:
+    # A symbolic link is not followed into, so a link cannot loop the listing.
+    return folder.is_dir() and not folder.is_symlink() and not (folder / "SKILL.md").exists()
+
+
+def _skill_folders(group: Path) -> Iterator[Path]:
+    for entry in sorted(group.iterdir()):
+        if entry.is_dir() and (entry / "SKILL.md").exists():
+            yield entry
+        elif _is_group(entry):
+            yield from _skill_folders(entry)
+
+
+class _RepositoryPaths(TauPaths):
+    """Tau paths that read the repository as a coding harness: `.tau` and `.agents`.
+
+    This is Tau's own scope, with nested skills. It is selected with
+    `TAU_INCLUDE_DEVELOPMENT_RESOURCES` for an Agent that is a coding agent over its own
+    repository, whose root `AGENTS.md` and `.agents/` are its instructions (ADR 0025, section 2).
+    Tau rebuilds its resource paths on load and reload but keeps this object, so the scope holds
+    on both.
+    """
+
+    __slots__ = ()
+
+    # Read by the project instruction filter of `context_compat`.
+    reads_development_resources: ClassVar[bool] = True
+
+    def project_skills_dir(self, cwd: Path) -> Path:
+        return _SkillsDir(super().project_skills_dir(cwd))
+
+    def project_agents_skills_dir(self, cwd: Path) -> Path:
+        return _SkillsDir(super().project_agents_skills_dir(cwd))
+
+
+class _TauOnlyPaths(_RepositoryPaths):
+    """Tau paths that read the Agent's project resources from `.tau` alone (ADR 0025).
+
+    The project's `.agents/skills`, `.agents/prompts` and `.agents/AGENTS.md` hold instructions
+    for the coding agents that develop the repository, not for the Agent it deploys. Every
+    `.agents` project location resolves to its `.tau` counterpart here; Tau de-duplicates the
+    repeated directories, so each is read once. The `AGENTS.md` files Tau finds without consulting
+    these paths are removed by the filter of `context_compat`, which reads the class attribute.
+    """
+
+    __slots__ = ()
+
+    reads_development_resources: ClassVar[bool] = False
+
+    def project_agents_dir(self, cwd: Path) -> Path:
+        return self.project_tau_dir(cwd)
+
+    def project_agents_skills_dir(self, cwd: Path) -> Path:
+        return self.project_skills_dir(cwd)
+
+    def project_agents_prompts_dir(self, cwd: Path) -> Path:
+        return self.project_prompts_dir(cwd)
+
+
+def tau_resource_paths(
+    cwd: Path,
+    *,
+    state_home: Path,
+    include_development_resources: bool = False,
+) -> TauResourcePaths:
+    """Return SDK defaults plus Tau-native project resource discovery.
+
+    `root` stays on the packaged resources, which are read-only inputs: an
+    installed wheel lives in site-packages, so the SDK must never write there.
+    `paths` therefore sends every durable Tau write — built-in extension state,
+    provider credentials, project trust, diagnostics, sessions — to the
+    writable `state_home` instead.
+
+    Project resources come from `.tau` alone unless `include_development_resources`
+    also admits the repository's `AGENTS.md` files and `.agents/`. The version-locked
+    filter that keeps Tau's `AGENTS.md` discovery to `.tau` is installed here, before
+    the session that uses these paths loads; it fails on an unreviewed Tau version.
+    """
+    install_project_context_filter()
+    paths_class = _RepositoryPaths if include_development_resources else _TauOnlyPaths
+    return TauResourcePaths(
+        root=resource_root(),
+        cwd=cwd,
+        agents_root=None,
+        paths=paths_class(home=state_home),
+    )

{ms_tau_sdk-2.0.26.dev77 → ms_tau_sdk-2.0.26.dev78}/src/ms_tau_sdk/runtime/extensions.py

@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+import os
 from dataclasses import dataclass
+from pathlib import Path
 
+import structlog
 from tau_agent.types import JSONValue
 from tau_coding import CodingSession
 
@@ -94,3 +97,80 @@ class ProjectExtensionState:
             "extension_error_count": self.extension_error_count,
             "tool_catalog_digest": self.tool_catalog_digest or None,
         }
+
+
+_resources_logger = structlog.get_logger("ms_tau_sdk.runtime.resources")
+# Extension and trust diagnostics are logged with the extension composition.
+_RESOURCE_KINDS_LOGGED_ELSEWHERE = frozenset({"extension", "project-trust"})
+
+
+def _workspace_relative_path(path: Path | None, *, cwd: Path) -> str | None:
+    # Never an absolute path: a file above the workspace reads as `../AGENTS.md`.
+    if path is None:
+        return None
+    return Path(os.path.relpath(path.resolve(), cwd.resolve())).as_posix()
+
+
+def project_resources_summary(
+    session: CodingSession, *, cwd: Path, development_resources: bool
+) -> dict[str, JSONValue]:
+    """The Agent's resources Tau selected from the workspace (ADR 0025)."""
+    system_prompt_files: list[JSONValue] = [
+        _workspace_relative_path(path, cwd=cwd) for path in session.system_prompt_files
+    ]
+    context_files: list[JSONValue] = [
+        _workspace_relative_path(Path(context_file.path), cwd=cwd)
+        for context_file in session.context_files
+    ]
+    skills: list[JSONValue] = [*sorted(skill.name for skill in session.skills)]
+    prompt_templates: list[JSONValue] = [
+        *sorted(template.name for template in session.prompt_templates)
+    ]
+    return {
+        "developmentResources": development_resources,
+        "systemPromptFiles": system_prompt_files,
+        "contextFiles": context_files,
+        "skills": skills,
+        "promptTemplates": prompt_templates,
+    }
+
+
+def log_project_resources(
+    session: CodingSession,
+    *,
+    session_uid: str,
+    cwd: Path,
+    development_resources: bool,
+    phase: str,
+) -> None:
+    """Log what Tau selected and reported for the Agent's resources on load or reload."""
+    summary = project_resources_summary(
+        session, cwd=cwd, development_resources=development_resources
+    )
+    _resources_logger.info(
+        "runtime.project_resources.load.completed",
+        session_uid=session_uid,
+        phase=phase,
+        development_resources=development_resources,
+        system_prompt_files=summary["systemPromptFiles"],
+        context_files=summary["contextFiles"],
+        skill_count=len(session.skills),
+        prompt_template_count=len(session.prompt_templates),
+    )
+    workspace = str(cwd.resolve())
+    for diagnostic in session.resource_diagnostics:
+        if diagnostic.kind in _RESOURCE_KINDS_LOGGED_ELSEWHERE:
+            continue
+        log = {"error": _resources_logger.error, "warning": _resources_logger.warning}.get(
+            diagnostic.severity, _resources_logger.info
+        )
+        log(
+            "runtime.project_resources.diagnostic",
+            session_uid=session_uid,
+            phase=phase,
+            resource_kind=diagnostic.kind,
+            resource_name=diagnostic.name,
+            resource_path=_workspace_relative_path(diagnostic.path, cwd=cwd),
+            diagnostic_severity=diagnostic.severity,
+            message=diagnostic.message.replace(workspace, "."),
+        )

{ms_tau_sdk-2.0.26.dev77 → ms_tau_sdk-2.0.26.dev78}/src/ms_tau_sdk/runtime/manager.py

@@ -59,6 +59,8 @@ from ms_tau_sdk.runtime.events import TauRuntimeEvent
 from ms_tau_sdk.runtime.extensions import (
     TASK_CONTROL_TOOL_NAMES,
     ProjectExtensionState,
+    log_project_resources,
+    project_resources_summary,
     validate_tool_catalog,
 )
 from ms_tau_sdk.runtime.live_turns import LiveTurn, LocalChatTurn
@@ -327,6 +329,7 @@ class SessionRuntimeManager:
             "mode": "local" if self.settings.local_mode else "managed",
             "exclude_base_tools": self.settings.exclude_base_tools,
             "exclude_mainsequence_mcp": self.settings.exclude_mainsequence_mcp,
+            "include_development_resources": self.settings.include_development_resources,
             "base_tool_count": 0 if self.settings.exclude_base_tools else 4,
             "task_control_tool_count": 2,
             "workspace_digest": self.settings.workspace_digest,
@@ -612,6 +615,11 @@ class SessionRuntimeManager:
             "tools": tools,
             "extensions": extensions,
             "diagnostics": diagnostics,
+            "resources": project_resources_summary(
+                coding_session,
+                cwd=self.settings.workspace,
+                development_resources=self.settings.include_development_resources,
+            ),
         }
 
     def local_extension_source(self, session_uid: str, source_uid: str) -> dict[str, object]:
@@ -1193,6 +1201,7 @@ class SessionRuntimeManager:
                     resource_paths=tau_resource_paths(
                         cwd,
                         state_home=self.settings.tau_state_home,
+                        include_development_resources=(self.settings.include_development_resources),
                     ),
                     project_extensions_enabled=True,
                     trust_override="approve",
@@ -1211,6 +1220,13 @@ class SessionRuntimeManager:
                 coding_session=coding_session,
                 state=project_extension_state,
             )
+            log_project_resources(
+                coding_session,
+                session_uid=session_uid,
+                cwd=cwd,
+                development_resources=self.settings.include_development_resources,
+                phase="load",
+            )
             runtime = ActiveSessionRuntime(
                 session_uid=session_uid,
                 holder_id=self.holder_id,
@@ -1226,6 +1242,7 @@ class SessionRuntimeManager:
                 catalog_digest=bootstrap.provider_control.catalog_digest,
                 project_extension_state=project_extension_state,
                 validate_tool_catalog=check_catalog,
+                development_resources=self.settings.include_development_resources,
             )
             state = bootstrap.runtime_state
             runtime.runtime_activity = state.runtime_activity or "loading"

{ms_tau_sdk-2.0.26.dev77 → ms_tau_sdk-2.0.26.dev78}/src/ms_tau_sdk/runtime/session.py

@@ -14,7 +14,7 @@ from tau_coding.reload import CodingReloadSummary
 from ms_tau_sdk.backend.mcp import MainSequenceMCPClient
 from ms_tau_sdk.backend.models import TauTurnCommit
 from ms_tau_sdk.runtime.events import TauRuntimeEvent, translate_tau_event
-from ms_tau_sdk.runtime.extensions import ProjectExtensionState
+from ms_tau_sdk.runtime.extensions import ProjectExtensionState, log_project_resources
 from ms_tau_sdk.runtime.provenance import PROVENANCE_NAMESPACE, TurnProvenance
 from ms_tau_sdk.sessions.storage import BackendSessionStorage
 
@@ -52,6 +52,7 @@ class ActiveSessionRuntime:
     catalog_digest: str = ""
     project_extension_state: ProjectExtensionState | None = None
     validate_tool_catalog: Callable[[CodingSession], None] | None = None
+    development_resources: bool = False
 
     async def reload(self) -> CodingReloadSummary:
         """Reload Tau resources and reject an invalid replacement catalog."""
@@ -61,6 +62,13 @@ class ActiveSessionRuntime:
                 self.validate_tool_catalog(self.coding_session)
             if self.project_extension_state is not None:
                 self.project_extension_state.update_from_session(self.coding_session)
+            log_project_resources(
+                self.coding_session,
+                session_uid=self.session_uid,
+                cwd=self.coding_session.cwd,
+                development_resources=self.development_resources,
+                phase="reload",
+            )
             return summary
 
     async def prompt(

{ms_tau_sdk-2.0.26.dev77 → ms_tau_sdk-2.0.26.dev78}/src/ms_tau_sdk/settings.py

@@ -161,6 +161,12 @@ class TauSDKSettings(BaseSettings):
         default=False,
         validation_alias="TAU_EXCLUDE_MAINSEQUENCE_MCP",
     )
+    # Read the repository as a coding harness: its `AGENTS.md` files and `.agents/` join the
+    # Agent's `.tau` resources (ADR 0025). Off, the Agent reads `.tau` alone.
+    include_development_resources: bool = Field(
+        default=False,
+        validation_alias="TAU_INCLUDE_DEVELOPMENT_RESOURCES",
+    )
     local_custom_id: str | None = Field(default=None, validation_alias="TAU_LOCAL_CUSTOM_ID")
     local_organization_environment_uid: str | None = Field(
         default=None, validation_alias="TAU_LOCAL_ORGANIZATION_ENVIRONMENT_UID"

ms_tau_sdk-2.0.26.dev77/src/ms_tau_sdk/resources/loader.py

@@ -1,76 +0,0 @@
-"""Packaged Tau resource paths with project-native override semantics."""
-
-from __future__ import annotations
-
-from collections.abc import Generator, Iterator
-from importlib.resources import files
-from pathlib import Path
-from typing import Self
-
-from tau_coding.paths import TauPaths
-from tau_coding.resources import TauResourcePaths
-
-
-def resource_root() -> Path:
-    return Path(str(files("ms_tau_sdk.resources")))
-
-
-class _SkillsDir(Path):
-    """A skills directory whose listing also holds the skills inside its group folders.
-
-    Tau reads the folders directly in a skills directory, so the skills in a folder without a
-    `SKILL.md`, such as `.agents/skills/mcp_tools/<skill>/SKILL.md`, were skipped. Listing them
-    beside the direct entries lets Tau read, index, reload and serve them like any other skill.
-    """
-
-    def iterdir(self) -> Generator[Self]:
-        for entry in sorted(Path(self).iterdir()):
-            yield self.with_segments(entry)
-            if _is_group(entry):
-                yield from map(self.with_segments, _skill_folders(entry))
-
-
-def _is_group(folder: Path) -> bool:
-    # A symbolic link is not followed into, so a link cannot loop the listing.
-    return folder.is_dir() and not folder.is_symlink() and not (folder / "SKILL.md").exists()
-
-
-def _skill_folders(group: Path) -> Iterator[Path]:
-    for entry in sorted(group.iterdir()):
-        if entry.is_dir() and (entry / "SKILL.md").exists():
-            yield entry
-        elif _is_group(entry):
-            yield from _skill_folders(entry)
-
-
-class _NestedSkillsPaths(TauPaths):
-    """Tau paths whose project skills directories read nested skills.
-
-    Tau rebuilds its resource paths on load and reload but keeps this object, so nested skills
-    are read on both.
-    """
-
-    __slots__ = ()
-
-    def project_skills_dir(self, cwd: Path) -> Path:
-        return _SkillsDir(super().project_skills_dir(cwd))
-
-    def project_agents_skills_dir(self, cwd: Path) -> Path:
-        return _SkillsDir(super().project_agents_skills_dir(cwd))
-
-
-def tau_resource_paths(cwd: Path, *, state_home: Path) -> TauResourcePaths:
-    """Return SDK defaults plus Tau-native project resource discovery.
-
-    `root` stays on the packaged resources, which are read-only inputs: an
-    installed wheel lives in site-packages, so the SDK must never write there.
-    `paths` therefore sends every durable Tau write — built-in extension state,
-    provider credentials, project trust, diagnostics, sessions — to the
-    writable `state_home` instead.
-    """
-    return TauResourcePaths(
-        root=resource_root(),
-        cwd=cwd,
-        agents_root=None,
-        paths=_NestedSkillsPaths(home=state_home),
-    )