@passioncode-ai/fabric-agent-adapter 0.39.1 → 0.41.0

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/dashboard-links.md

@@ -83,8 +83,10 @@ or instructions alone do not prove all final answers from every agent are filter
   path is required. Skills must be activated/loaded; install does not intercept every answer.
 - MCP absent: report unresolved host capability once, use the project's approved
   resolver/CLI if available. Do not write machine or agent MCP config automatically.
-- Python absent: perform the comparisons above manually; mark the executable gate
-  NOT_RUN. Do not label the output mechanically validated.
+- Python absent: perform the comparisons above manually, including the gate's own rules (a
+  path with a `.` or `..` segment, an encoded or backslash separator, or a query or fragment
+  name or value that reads as a credential, such as `code`, `key`, `auth` or `api_key`, is
+  refused); mark the executable gate NOT_RUN. Do not label the output mechanically validated.
 
 Syntax is owned by Fabric Dashboards and `@passioncode-ai/fabric-service-host`:
 [ADR-0005](https://github.com/passioncode-ai/fabric-dashboards/blob/51a7a80acf42781d7bec304cc87c655d48cc309b/docs/adr/0005-service-links.md).

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/operator-channel-and-repository.md

@@ -0,0 +1,55 @@
+# The operator channel and the repository standard
+
+Shared by `adapting-projects-to-fabric` and `creating-fabric-agents`; the two copies are byte-identical
+(`test/test_shared_references.py`). "The agent" is the provider being adapted or created.
+
+## The operator channel
+
+If the agent has a human stop (a choice, an approval, a confirmation) or emits `notify: true`
+events, propose its **operator channel** to the operator once, at the step that links here. The
+channel is the agent's own messenger channel, first Telegram, that sends those events and answers
+its stops with buttons: `fabric-operator-channel/0.1` (contract DEC-0034,
+`docs/specification/operator-channel.md`), whose rule OC-11 this follows. Give the operator's four
+steps:
+
+1. create a bot with @BotFather;
+2. put its token into the operator's secret store (Project Observatory where it is installed) under
+   the name the agent reads (for example `EXAMPLE_AGENT_TELEGRAM_BOT_TOKEN`), never into a chat, a
+   file or the bundle;
+3. run the agent's link command;
+4. type the code it shows in the chat with the bot.
+
+In a group shared with other bots the channel follows OC-14 to OC-17 (DEC-0035): it stays silent
+unless addressed (`/command@ThisBot`, a reply to its own message or a press of its own button; a
+bare `/command` in a group is not addressed), and a channel nobody receives on is `degraded`
+(`receiver-missing`). Say so in the proposal when the operator means to bind a shared group.
+
+Record the answer (`accepted`, `declined` or `later`) in the agent's state and in its conformance
+report, and do not ask again; an agent that serves `surfaces.operatorChannel` also shows it as
+`proposal` in its status document. Creating the bot, storing the token and enabling the channel
+are the operator's action: never create the bot, ask for or store the token's value, or enable the
+channel yourself. The default pin carries DEC-0034 and DEC-0035: a served status document is
+checked against the pinned `schemas/operator-channel-status.schema.json`; the channel's runtime
+rules have no probe rule here yet, so report them `NOT_RUN`. An agent with neither stops nor notify
+events skips this.
+
+## The repository standard
+
+For a PassionCode.ai repository, the agent's repository follows the organization's
+[repository standard](https://github.com/passioncode-ai/fabric-workspace/blob/main/knowledge/repository-standard.md)
+(`knowledge/repository-standard.md` in the organization's knowledge base; a clone has it at
+`fabric-workspace/knowledge/`) from its first commit:
+
+- `LICENSE`, `COMMERCIAL-LICENSE.md` and `CLA.md` copied byte for byte from the knowledge base's
+  `templates/`, and `AGPL-3.0-only OR LicenseRef-PassionCode-Commercial` in every manifest and
+  every SKILL.md `license:`; `SECURITY.md` when the repository is public;
+- a README whose first heading is the full name, with `## Quick start for a new teammate`
+  (Install; Configure, key names only; MCP, the registration command and one proving tool call,
+  verified with a real client in a temporary config; Develop) and `## License`;
+- an `AGENTS.md` that opens with the template's *Read first* block and closes with *After work*,
+  and a `CLAUDE.md` whose first line is `@AGENTS.md`.
+
+org-index `scripts/check_format.py` reports 0 findings for it before it is called done. An agent
+someone builds for themselves is not a PassionCode.ai repository: its licence is its owner's
+choice, nothing about it is published or listed by the organization, and none of these files is
+required of it, though the verified MCP quick start is still how anyone learns to drive it.

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/provider-entry.md

@@ -32,7 +32,9 @@ python3 scripts/fabric_provider.py validate ~/Library/Application\ Support/ai.pa
 python3 scripts/fabric_provider.py remove example-agent      # the uninstaller
 ```
 
-`--stdio` takes the rest of the line as the argument array; there is no shell string. An entry may carry
+`--stdio` comes last and takes the rest of the line as the argument array; there is no shell string. A writer
+option after it (`--env`, `--name`, ...) is refused rather than swallowed into argv; write `--stdio -- EXECUTABLE ...`
+when the server itself takes an option of that name. `--env` belongs to a stdio server and is refused with `--url`. An entry may carry
 `run.mcp.stdio.scope` (DEC-0044): `project` (started for the sessions of a project that binds it) or `on-demand`;
 `session` (a server in every coding session) is refused (FAC-SEM-056, LC-19). The validator accepts the field; the
 writer does not set it until Fabric reads it. An argument that carries a credential is refused
@@ -46,8 +48,12 @@ It refuses, with one sentence that never quotes a value:
 - an env value that is not `secret-ref:<name>`, or a reference that has the shape of a
   credential itself: a token prefix, a private key, a JWT (FAC-SEM-015: a value is
   checked by its form; name patterns apply to names);
-- a URL other than `http://127.0.0.1:<port>/mcp`, a manifest path that is not an
-  absolute or `~/` path to `fabric-agent.json`, a shell-string command, unknown fields.
+- what the pinned `provider.schema.json` refuses: a URL other than `http://127.0.0.1:<port>/mcp` with a port from 100
+  to 65535, a manifest path that is not an absolute or `~/` path to `fabric-agent.json` (or is a network share, or over
+  1024 characters), a shell-string command, more than 32 arguments or one over 1024 characters, more than 64 env
+  names, a `source.repository` that is not an absolute URI, an `installedAt` that is not an RFC 3339 date-time,
+  unknown fields. The patterns are the schema's, copied (`test_provider.SchemaParityTests` compares them with a
+  contract checkout at the pin when `FABRIC_CONTRACT_NEW` names one).
 
 `validate` also checks that the file is named `<id>.json` (FAC-SEM-014, slug half).
 From Python: `write_provider_entry(entry)`, `remove_provider_entry(id)`,

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/verification.md

@@ -18,6 +18,21 @@ Use only `PASS`, `FAIL`, `NOT_RUN`, and `NOT_VERIFIED`:
 - `NOT_VERIFIED`: no implemented verifier/runtime currently exists for the claim.
 - Never relabel either as a warning-level pass.
 
+## Template sentinels
+
+`check` lists every value the scaffold invented as a warning, and `readyForAdmission` stays false
+while one remains: `placeholder:` for a fixed sentinel (the zero content hash, `replace-me`,
+`.invalid`, `urn:fabric:adapter:author`, the generic probe assertion, a generated file still marked
+`fabric-adapter-template` or still in the generic request/summary shape, the generic fixture) and
+`template-default:` for each JSON pointer listed under the manifest's `urn:fabric:adapter:template`
+extension (a legal value the author did not choose, such as `dataClasses: ["public"]`). A warning
+is cleared by replacing the value with an implementation-backed fact and removing the pointer from
+that list; deleting the block without confirming its values is a false receipt.
+
+`check --contract` runs the checkout's own `node_modules/.bin/tsx`, never `pnpm exec`, so it cannot
+reinstall or purge the contract checkout. A manifest that is not UTF-8 or not JSON is an
+`invalid-json:` receipt, not a crash.
+
 ## Receipts
 
 A receipt names what ran and what identity was tested:

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/scripts/adapt_project.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 import argparse
 import datetime as dt
+import difflib
 import json
 import math
 import os
@@ -43,6 +44,22 @@ GENERATED_PATHS = (
 )
 
 
+# #region template-sentinels
+# Every value the scaffold invents is a sentinel `check` finds: a fixed string, a `$comment` or Markdown mark, or a
+# JSON pointer listed under TEMPLATE_KEY in the manifest's extensions (a value that is legal but was not chosen by the
+# author, such as dataClasses ["public"]). readyForAdmission stays false while one remains.
+TEMPLATE_KEY = "urn:fabric:adapter:template"
+TEMPLATE_MARK = "fabric-adapter-template"
+AUTHOR_SENTINEL = "urn:fabric:adapter:author"
+WEAK_ASSERTION = "returns a typed result without external effects"
+FIXTURE_SENTINEL = "Return one bounded, non-publishing test result."
+ZERO_HASH = "sha256:" + ("0" * 64)
+PLACEHOLDER_TEXT = ("replace-me", ".invalid")
+DATA_CLASSES = ("public", "project-internal", "confidential", "personal", "credential", "regulated")
+IDENTITY_METHODS = ("tls", "oauth2", "signed-manifest", "local-install")
+# #endregion template-sentinels
+
+
 class AdaptationError(Exception):
     """Expected user-facing adaptation error."""
 
@@ -84,7 +101,7 @@ def inspect_project(root: Path) -> Dict[str, Any]:
     if not root.is_dir():
         raise AdaptationError("project path is not a directory: %s" % root)
 
-    evidence: Dict[str, List[str]] = {"mcp": [], "a2a": [], "local-runner": [], "autonomous": []}
+    evidence: Dict[str, List[str]] = {"mcp": [], "a2a": [], "local-runner": [], "autonomous": [], "mcp-client-config": []}
     sampled = 0
     file_count = 0
     for path in _files(root):
@@ -93,7 +110,11 @@ def inspect_project(root: Path) -> Dict[str, Any]:
         lower_rel = rel.lower()
         if lower_rel.endswith("agent-card.json") or ".well-known/agent-card" in lower_rel:
             evidence["a2a"].append("file:%s" % rel)
-        if "mcp" in Path(lower_rel).name:
+        client_config = _is_mcp_client_config(path)
+        if client_config:
+            # A client's server list (.mcp.json, mcpServers) says what the project CALLS, not what it serves.
+            evidence["mcp-client-config"].append("file:%s" % rel)
+        elif "mcp" in Path(lower_rel).name:
             evidence["mcp"].append("file:%s" % rel)
         if lower_rel.startswith("bin/") or lower_rel in {"cli.py", "cli.js", "cli.ts"}:
             evidence["local-runner"].append("file:%s" % rel)
@@ -105,7 +126,7 @@ def inspect_project(root: Path) -> Dict[str, Any]:
             continue
         sampled += 1
         lowered = text.lower()
-        if "@modelcontextprotocol/sdk" in lowered or "fastmcp" in lowered or "model context protocol" in lowered:
+        if not client_config and ("@modelcontextprotocol/sdk" in lowered or "fastmcp" in lowered or "model context protocol" in lowered):
             evidence["mcp"].append("content:%s" % rel)
         if '"a2a"' in lowered or "agent card" in lowered or "/.well-known/agent-card.json" in lowered:
             evidence["a2a"].append("content:%s" % rel)
@@ -136,6 +157,9 @@ def inspect_project(root: Path) -> Dict[str, Any]:
     else:
         recommendation = "undetermined"
         question = "Which capability is being adapted, and who owns its task lifecycle?"
+    if evidence["mcp-client-config"] and "mcp" not in candidates:
+        question = ("The project configures MCP clients (%s); that lists servers it calls, not one it serves. "
+                    "Does it also serve an MCP server Fabric can call? %s" % (", ".join(evidence["mcp-client-config"][:3]), question or ""))
 
     return {
         "project": str(root.resolve()),
@@ -149,6 +173,15 @@ def inspect_project(root: Path) -> Dict[str, Any]:
     }
 
 
+def _is_mcp_client_config(path: Path) -> bool:
+    if path.name.lower() in (".mcp.json", "claude_desktop_config.json"):
+        return True
+    if path.suffix.lower() not in (".json", ".toml", ".yaml", ".yml"):
+        return False
+    text = _read_text(path).lower()
+    return "mcpservers" in text or "mcp_servers" in text
+
+
 def _require_absolute_uri(value: str, label: str) -> None:
     parsed = urlparse(value)
     if not parsed.scheme:
@@ -171,7 +204,7 @@ def _profile(args: argparse.Namespace, schema_base: str) -> Dict[str, Any]:
         "outputSchema": output_uri,
         "timeoutMs": 30000,
         "sideEffectCeiling": "none",
-        "assertions": ["returns a typed result without external effects"],
+        "assertions": list(getattr(args, "probe_assertion", None) or [WEAK_ASSERTION]),
     }
     if profile == "mcp":
         if args.mcp_mode == "stdio":
@@ -245,6 +278,29 @@ def _generated_files(args: argparse.Namespace) -> Dict[str, str]:
         if _secrets.secret_argument(runtime_arg):
             raise AdaptationError("a runtime argument carries a credential; argv is visible to every process (LC-21): read it from a secret reference instead")
 
+    defaulted: List[str] = []
+    created_by = getattr(args, "created_by", None)
+    if created_by:
+        _require_absolute_uri(created_by, "created-by")
+    else:
+        created_by = AUTHOR_SENTINEL
+        defaulted.append("/provider/createdBy")
+    local = args.profile == "local-runner" or (args.profile == "mcp" and args.mcp_mode == "stdio")
+    identity_method = getattr(args, "identity_method", None)
+    if not identity_method:
+        identity_method = "local-install" if local else "tls"
+        if not local:
+            defaulted.append("/provider/identity/method")
+    elif identity_method not in IDENTITY_METHODS:
+        raise AdaptationError("unknown identity method %r (%s)" % (identity_method, ", ".join(IDENTITY_METHODS)))
+    data_classes = list(dict.fromkeys(getattr(args, "data_class", None) or []))
+    if any(c not in DATA_CLASSES for c in data_classes):
+        raise AdaptationError("unknown data class (%s)" % ", ".join(DATA_CLASSES))
+    if not data_classes:
+        data_classes = ["public"]
+        defaulted.append("/capabilities/0/dataClasses")
+    if not getattr(args, "probe_assertion", None):
+        defaulted.append("/capabilities/0/profile/probes/0/assertions")
     created_at = dt.datetime.now(dt.timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
     # DEC-0076: a writer emits identifiers in their normal form, so every reader finds them under one spelling.
     provider_id = _normal_identifier(args.provider_id)
@@ -256,11 +312,11 @@ def _generated_files(args: argparse.Namespace) -> Dict[str, str]:
             "revision": 1,
             "contentHash": "sha256:" + ("0" * 64),
             "createdAt": created_at,
-            "createdBy": "urn:fabric:adapter:author",
+            "createdBy": created_by,
             "name": args.provider_name,
             "identity": {
                 "subject": provider_id,
-                "method": "local-install" if args.profile == "local-runner" or (args.profile == "mcp" and args.mcp_mode == "stdio") else "tls",
+                "method": identity_method,
             },
             "supportedContractVersions": [CONTRACT_VERSION],
         },
@@ -272,7 +328,7 @@ def _generated_files(args: argparse.Namespace) -> Dict[str, str]:
                 "outputSchema": _schema_uri(args.schema_base, "schemas/capability-output.schema.json"),
                 "effect": effect,
                 "idempotency": idempotency,
-                "dataClasses": ["public"],
+                "dataClasses": data_classes,
                 "profile": _profile(args, args.schema_base),
             }
         ],
@@ -282,6 +338,11 @@ def _generated_files(args: argparse.Namespace) -> Dict[str, str]:
     presets = _cost_presets(args)
     if presets:
         manifest["costPresets"] = presets
+    if defaulted:
+        manifest["extensions"] = {TEMPLATE_KEY: {
+            "defaulted": defaulted,
+            "note": "The scaffold chose these values. Confirm or replace each one, remove it from this list, and remove this block when the list is empty; check keeps readyForAdmission false while it remains.",
+        }}
     lock = {
         "contract": "fabric-agent-contract",
         "version": CONTRACT_VERSION,
@@ -293,6 +354,7 @@ def _generated_files(args: argparse.Namespace) -> Dict[str, str]:
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "$id": _schema_uri(args.schema_base, "schemas/capability-input.schema.json"),
         "title": "Capability input",
+        "$comment": TEMPLATE_MARK + ": a generic placeholder; replace it with the capability's real input schema.",
         "type": "object",
         "additionalProperties": False,
         "properties": {"request": {"type": "string", "minLength": 1}},
@@ -302,6 +364,7 @@ def _generated_files(args: argparse.Namespace) -> Dict[str, str]:
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "$id": _schema_uri(args.schema_base, "schemas/capability-output.schema.json"),
         "title": "Capability output",
+        "$comment": TEMPLATE_MARK + ": a generic placeholder; replace it with the capability's real output schema.",
         "type": "object",
         "additionalProperties": False,
         "properties": {
@@ -310,8 +373,8 @@ def _generated_files(args: argparse.Namespace) -> Dict[str, str]:
         },
         "required": ["summary", "evidence"],
     }
-    fixture = {"request": "Return one bounded, non-publishing test result."}
-    assertions = """# Admission probe assertions
+    fixture = {"request": FIXTURE_SENTINEL}
+    assertions = "<!-- " + TEMPLATE_MARK + ": generic assertions; replace them with what this capability's probe proves. -->\n" + """# Admission probe assertions
 
 - The result validates against `capability-output.schema.json`.
 - Every claimed fact has a resolvable evidence URI.
@@ -324,10 +387,10 @@ Contract: `fabric-agent-contract` 0.1.0 at `%s`
 
 | Gate | Status | Receipt / next action |
 |---|---|---|
-| Declaration shape | NOT VERIFIED | Run `adapt_project.py check . --contract /path/to/fabric-agent-contract`. |
-| Protocol revision and connection | NOT VERIFIED | Replace profile placeholders, then negotiate the exact pinned revision. |
-| Semantic probes | NOT VERIFIED | Implement and run the bounded fixture and assertions against the provider. |
-| Project binding readiness | NOT VERIFIED | Requires an admitted capability and Fabric host runtime. |
+| Declaration shape | NOT_VERIFIED | Run `adapt_project.py check . --contract /path/to/fabric-agent-contract`. |
+| Protocol revision and connection | NOT_VERIFIED | Replace profile placeholders, then negotiate the exact pinned revision. |
+| Semantic probes | NOT_VERIFIED | Implement and run the bounded fixture and assertions against the provider. |
+| Project binding readiness | NOT_VERIFIED | Requires an admitted capability and Fabric host runtime. |
 
 The zero content hash, `replace-me` values, and `.invalid` endpoints are deliberate
 placeholders. Scaffolding is not admission and must not be presented as compatibility.
@@ -345,7 +408,7 @@ placeholders. Scaffolding is not admission and must not be presented as compatib
 
 EFFECT_CLASSES = ("none", "draft", "publish", "send", "reply", "charge", "delete", "merge", "deploy", "change-policy")
 IDEMPOTENCY = ("required", "supported", "none")
-_PRESET_ID = re.compile(r"^[a-z][a-z0-9-]{0,39}$")
+_PRESET_ID = re.compile(r"^[a-z][a-z0-9-]{0,39}\Z")  # \Z, not `$`: `$` also matches before a trailing newline (R1)
 
 
 def _cost_presets(args: argparse.Namespace) -> List[Dict[str, Any]]:
@@ -393,6 +456,23 @@ def scaffold_project(root: Path, args: argparse.Namespace) -> Dict[str, Any]:
         raise AdaptationError("project path is not a directory: %s" % root)
     generated = _generated_files(args)
     collisions = [rel for rel in generated if (root / rel).exists()]
+    if getattr(args, "dry_run", False):
+        diffs: Dict[str, str] = {}
+        for rel in collisions:
+            try:
+                old = (root / rel).read_text(encoding="utf-8", errors="replace").splitlines(keepends=True)
+            except OSError as exc:
+                old = ["<unreadable: %s>\n" % exc.__class__.__name__]
+            diffs[rel] = "".join(difflib.unified_diff(old, generated[rel].splitlines(keepends=True), fromfile=rel, tofile=rel))
+        return {
+            "project": str(root.resolve()),
+            "profile": args.profile,
+            "dryRun": True,
+            "wouldCreate": sorted(set(generated) - set(collisions)),
+            "wouldReplace": sorted(collisions),
+            "needsForce": bool(collisions) and not args.force,
+            "diffs": diffs,
+        }
     if collisions and not args.force:
         raise AdaptationError("refusing to overwrite existing paths: %s" % ", ".join(collisions))
     for rel, content in generated.items():
@@ -413,8 +493,8 @@ def _load_json(path: Path, errors: List[str]) -> Optional[Any]:
         return json.loads(path.read_text(encoding="utf-8"))
     except FileNotFoundError:
         errors.append("missing:%s" % path.name)
-    except (OSError, json.JSONDecodeError) as exc:
-        errors.append("invalid-json:%s:%s" % (path.name, exc))
+    except (OSError, ValueError) as exc:  # ValueError: JSONDecodeError and UnicodeDecodeError (a non-UTF-8 file)
+        errors.append("invalid-json:%s:%s" % (path.name, exc.__class__.__name__ if isinstance(exc, UnicodeError) else exc))
     return None
 
 
@@ -426,7 +506,9 @@ def _walk_keys(value: Any, prefix: str = "") -> Iterable[Tuple[str, Any]]:
             yield from _walk_keys(item, here)
     elif isinstance(value, list):
         for index, item in enumerate(value):
-            yield from _walk_keys(item, "%s[%d]" % (prefix, index))
+            here = "%s[%d]" % (prefix, index)
+            yield here, item
+            yield from _walk_keys(item, here)
 
 
 def _contract_shape(manifest: Path, contract: Path, selected_commit: str) -> Tuple[str, List[str]]:
@@ -452,8 +534,9 @@ def _contract_shape(manifest: Path, contract: Path, selected_commit: str) -> Tup
         return "NOT_RUN", ["cannot verify clean contract checkout: %s" % exc]
     if dirty:
         return "FAIL", ["contract checkout has modifications; exact selected schema is required"]
-    if not (contract / "node_modules/.bin/tsx").is_file():
-        return "NOT_RUN", ["pinned contract dependencies are missing; run pnpm install --frozen-lockfile"]
+    tsx = contract / "node_modules/.bin/tsx"
+    if not tsx.is_file():
+        return "NOT_RUN", ["pinned contract dependencies are missing; run pnpm install --frozen-lockfile in the contract checkout"]
 
     code = """import {readFile} from 'node:fs/promises';
 import {createValidator,validateDocument} from './src/validator.ts';
@@ -465,13 +548,15 @@ import {SCHEMA_PREFIX} from './src/contract.ts';
   process.exit(result.valid?0:3);
 })().catch((error) => { console.error(error); process.exit(4); });"""
     try:
+        # The checkout's own tsx, called directly: `pnpm exec` may decide the modules folder is stale and purge and
+        # reinstall a checkout that is not this tool's to change (ERR_PNPM_UNSAFE_MODULES_DIR).
         run = subprocess.run(
-            ["pnpm", "exec", "tsx", "-e", code, str(manifest.resolve())],
+            [str(tsx), "-e", code, str(manifest.resolve())],
             cwd=str(contract), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
             timeout=120,
         )
-    except FileNotFoundError:
-        return "NOT_RUN", ["pnpm is unavailable; install the pinned contract dependencies"]
+    except OSError as exc:
+        return "NOT_RUN", ["the contract checkout's tsx could not start (%s); is node on PATH?" % exc.__class__.__name__]
     except subprocess.TimeoutExpired:
         return "NOT_RUN", ["contract shape validation timed out"]
     if run.returncode != 0:
@@ -534,6 +619,58 @@ def _plugin_problems(root: Path) -> List[str]:
     return problems
 
 
+def _template_block_warnings(manifest: Dict[str, Any], errors: List[str]) -> List[str]:
+    """The pointers the scaffold recorded as its own choices (TEMPLATE_KEY); each stays a warning until removed."""
+    extensions = manifest.get("extensions")
+    block = extensions.get(TEMPLATE_KEY) if isinstance(extensions, dict) else None
+    if block is None:
+        return []
+    pointers = block.get("defaulted") if isinstance(block, dict) else None
+    if not isinstance(pointers, list) or not all(isinstance(p, str) for p in pointers):
+        errors.append("extensions.%s must be {\"defaulted\": [JSON pointers]}" % TEMPLATE_KEY)
+        return []
+    if not pointers:
+        return ["template-default:extensions.%s is empty; remove the block" % TEMPLATE_KEY]
+    return ["template-default:%s (chosen by the scaffold; confirm or replace it, then remove it from extensions.%s)" % (p, TEMPLATE_KEY)
+            for p in pointers]
+
+
+def _template_file_warnings(root: Path) -> List[str]:
+    """Sentinels in the generated files other than the manifest: placeholder text, the template mark, the generic
+    schemas and fixture (also recognised by shape when the mark was removed but the schema was not replaced)."""
+    warnings: List[str] = []
+    for rel in GENERATED_PATHS[1:]:
+        if rel == "fabric/FABRIC-CONFORMANCE.md":
+            continue  # the status page names the placeholders to explain them; it is the author's to keep
+        path = root / rel
+        if not path.is_file():
+            continue
+        text = _read_text(path)
+        if TEMPLATE_MARK in text:
+            warnings.append("placeholder:%s (the scaffold's generic template)" % rel)
+        elif any(marker in text for marker in PLACEHOLDER_TEXT):
+            warnings.append("placeholder:%s" % rel)
+    generic_shapes = {
+        "fabric/schemas/capability-input.schema.json": {"request"},
+        "fabric/schemas/capability-output.schema.json": {"summary", "evidence"},
+    }
+    for rel, keys in generic_shapes.items():
+        try:
+            schema = json.loads((root / rel).read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            continue
+        properties = schema.get("properties") if isinstance(schema, dict) else None
+        if isinstance(properties, dict) and set(properties) == keys and TEMPLATE_MARK not in json.dumps(schema):
+            warnings.append("placeholder:%s (still the scaffold's generic shape)" % rel)
+    try:
+        fixture = json.loads((root / "fabric/fixtures/admission-input.json").read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        fixture = None
+    if isinstance(fixture, dict) and FIXTURE_SENTINEL in fixture.values():
+        warnings.append("placeholder:fabric/fixtures/admission-input.json (the scaffold's generic fixture)")
+    return warnings
+
+
 def check_project(root: Path, contract: Optional[Path]) -> Dict[str, Any]:
     errors: List[str] = []
     warnings: List[str] = []
@@ -601,12 +738,18 @@ def check_project(root: Path, contract: Optional[Path]) -> Dict[str, Any]:
             normalized = key.lower().replace("_", "").replace("-", "")
             if any(secret in normalized for secret in ("password", "apikey", "accesstoken", "clientsecret", "privatekey")):
                 errors.append("secret-like field is forbidden in manifest: %s" % key)
-            if isinstance(value, str) and ("replace-me" in value or ".invalid" in value):
+            if isinstance(value, str) and any(text in value for text in PLACEHOLDER_TEXT):
                 warnings.append("placeholder:%s" % key)
+            if value == AUTHOR_SENTINEL:
+                warnings.append("placeholder:%s" % key)
+            if value == WEAK_ASSERTION:
+                warnings.append("placeholder:%s (a generic probe assertion; state what the probe proves)" % key)
         errors.extend(_credential_problems(manifest))
         provider = manifest.get("provider")
-        if isinstance(provider, dict) and provider.get("contentHash") == "sha256:" + ("0" * 64):
+        if isinstance(provider, dict) and provider.get("contentHash") == ZERO_HASH:
             warnings.append("placeholder:provider.contentHash")
+        warnings.extend(_template_block_warnings(manifest, errors))
+    warnings.extend(_template_file_warnings(root))
 
     shape_status = "NOT_RUN"
     shape_receipts = ["pass --contract PATH pointing at the pinned checkout"]
@@ -673,7 +816,13 @@ def build_parser() -> argparse.ArgumentParser:
                           help="a fixed cost option a launcher offers (DEC-0037 costPresets); repeat for each")
     scaffold.add_argument("--default-cost-preset", metavar="ID", help="the preset preselected at launch")
     scaffold.add_argument("--job", action="store_true", help="the capability's work may outlive one request (fabric-interop/0.1 job)")
-    scaffold.add_argument("--force", action="store_true")
+    scaffold.add_argument("--created-by", metavar="URI", help="the manifest author (provider.createdBy); a sentinel until given")
+    scaffold.add_argument("--identity-method", choices=IDENTITY_METHODS, help="provider.identity.method; a remote default of tls is a sentinel until given")
+    scaffold.add_argument("--data-class", action="append", choices=DATA_CLASSES, default=[],
+                          help="a data class the capability handles; repeat. Without it [public] is written as a sentinel")
+    scaffold.add_argument("--probe-assertion", action="append", default=[], help="what the admission probe proves; repeat. Without it a generic sentinel is written")
+    scaffold.add_argument("--force", action="store_true", help="replace the generated paths that exist; see --dry-run first")
+    scaffold.add_argument("--dry-run", action="store_true", help="print the planned writes and a unified diff of each existing path; write nothing")
     scaffold.add_argument("--json", action="store_true")
 
     check = sub.add_parser("check", help="check generated structure and optional pinned schema")
@@ -692,7 +841,13 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
             result = scaffold_project(args.project, args)
         else:
             result = check_project(args.project, args.contract)
-        _print(result, args.json)
+        if result.get("dryRun") and not args.json:
+            diffs = result.pop("diffs")
+            _print(result, False)
+            for rel in sorted(diffs):
+                print(diffs[rel], end="" if diffs[rel].endswith("\n") or not diffs[rel] else "\n")
+        else:
+            _print(result, args.json)
         if args.command == "check":
             gates = result["gates"]
             if gates["localStructure"]["status"] == "FAIL" or gates["declarationShape"]["status"] == "FAIL":

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/scripts/check_dashboard_link.py

@@ -7,7 +7,7 @@ This is an output correctness gate, not authentication, discovery, or a relay.
 import json
 import re
 import sys
-from urllib.parse import parse_qs, urlsplit
+from urllib.parse import parse_qs, parse_qsl, unquote, urlsplit
 
 
 def require(condition, reason):
@@ -15,6 +15,63 @@ def require(condition, reason):
         raise ValueError(reason)
 
 
+# Credential names and values: the same rules as fabric-button.js (credentialName, secretValue).
+CREDENTIAL_WORDS = {
+    'token', 'secret', 'password', 'passwd', 'pass', 'passphrase', 'credential', 'credentials', 'cookie',
+    'authorization', 'bearer', 'jwt', 'otp', 'apikey', 'signature', 'sig', 'accesstoken', 'idtoken', 'authtoken',
+    'refreshtoken', 'sessionid', 'sessiontoken', 'logincode', 'authcode', 'privatekey', 'clientsecret', 'secretkey',
+    'accesskey'}
+CREDENTIAL_PAIRS = {
+    'key': {'private', 'api', 'access', 'secret', 'session', 'auth', 'signing', 'encryption', 'master', 'client', 'login',
+            'refresh'},
+    'auth': {'token', 'code', 'header'},
+    'session': {'token', 'id'},
+    'code': {'login', 'auth', 'access', 'session'}}
+JWT_SHAPE = re.compile(r'eyJ[A-Za-z0-9_-]{2,}\.[A-Za-z0-9_-]{2,}\.[A-Za-z0-9_-]*')
+SECRET_VALUE = re.compile(r'(^bearer\s.+|sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|xox[abposr]-[A-Za-z0-9-]{10,}'
+                          r'|AKIA[0-9A-Z]{16}|glpat-[A-Za-z0-9_-]{20,})', re.I | re.S)
+LONG_RUN = re.compile(r'[A-Za-z0-9+/=_-]{40,}')
+
+
+def name_words(name):
+    name = re.sub(r'([a-z0-9])([A-Z])', r'\1 \2', name)
+    name = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\1 \2', name)
+    return [w.lower() for w in re.split(r'[\s._-]+', name) if w]
+
+
+def credential_name(name):
+    split = name_words(name)
+    words = set(split) | {w[:-1] for w in split if len(w) > 2 and w.endswith('s')}
+    if words & CREDENTIAL_WORDS:
+        return True
+    if len(split) == 1 and words & set(CREDENTIAL_PAIRS):
+        return True
+    return any(w in words and words & pairs for w, pairs in CREDENTIAL_PAIRS.items())
+
+
+def secret_value(value):
+    long_secret = any(re.search(r'[a-z]', run) and re.search(r'[A-Z]', run) and re.search(r'[0-9]', run)
+                      for run in LONG_RUN.findall(value))
+    return bool(JWT_SHAPE.search(value) or SECRET_VALUE.search(value) or long_secret)
+
+
+def carries_credential(text):
+    # A query or fragment whose names or values could be a credential: refused even with an empty value.
+    return (secret_value(text) or secret_value(unquote(text))
+            or any(credential_name(name) or secret_value(name) or secret_value(value)
+                   for name, value in parse_qsl(text, keep_blank_values=True)))
+
+
+def login_path(path):
+    # The path a server routes: refuse what normalises differently in different servers, then compare.
+    decoded = unquote(path)
+    require(not re.search(r'%2f|%5c', path, re.I) and '\\' not in decoded, 'encoded_separator')
+    segments = decoded.split('/')[1:]
+    require(not any(seg in ('.', '..') for seg in segments), 'dot_segment')
+    require(all(seg for seg in segments[:-1]), 'empty_segment')
+    return '/'.join([''] + [seg for seg in segments if seg]).lower() == '/fabric/v1/login'
+
+
 def safe_path(path):
     return (isinstance(path, str) and path.startswith('/') and not path.startswith('//')
             and len(path) <= 2048 and not re.search(r'[\\\x00-\x1f\x7f]', path))
@@ -42,10 +99,14 @@ def check(data):
             and not plain.username and not plain.password, 'invalid_http_fallback')
     http_page = plain.path + ('?' + plain.query if plain.query else '') + ('#' + plain.fragment if plain.fragment else '')
     require(safe_path(http_page) and http_page == (page or '/'), 'mismatched_page')
-    sensitive = {'token', 'access_token', 'refresh_token', 'password', 'secret', 'login_code'}
-    page_query = parse_qs(urlsplit(http_page).query)
-    require(not sensitive.intersection(k.lower() for k in page_query), 'credential_query')
-    require(urlsplit(http_page).path != '/fabric/v1/login', 'login_link_is_not_dashboard')
+    sensitive = {'token', 'access_token', 'refresh_token', 'password', 'secret', 'login_code', 'code', 'api_key',
+                 'apikey', 'key', 'auth'}
+    parts = urlsplit(http_page)
+    places = [parts.query, parts.fragment] + parts.fragment.split('?', 1)[1:]
+    require(not any(sensitive.intersection(k.lower() for k in parse_qs(p, keep_blank_values=True)) for p in places),
+            'credential_query')
+    require(not any(carries_credential(p) for p in places), 'credential_query')
+    require(not login_path(parts.path), 'login_link_is_not_dashboard')
     state = host.get('state')
     require(state in ('available', 'not_installed', 'unknown', 'incompatible', 'handler_mismatch', 'unsupported'), 'unknown_host_state')
     target, viewer = data.get('target_device'), data.get('viewer_device')