author-agentic-lens

name	author-agentic-lens
description	Author a shaped slice's agentic lens as an MD grounding doc — the is-it-an-agent gate, the load weights (cognitive / creative / logistical on a low→ultra scale), and the controls (guardrails, handoff) — from the slice's hub (its functionalities' grounding docs + the spine profile) and KB grounding. A slice that should offload nothing comes out "not an agent", stated plainly. Writes the per-node lens agentic.md (conforming to the Agentic lens template) STRAIGHT TO THE LIVE MODEL, plus a grounding manifest under STM that carries any autonomy decision as structured data; reads the functionality.md docs for the hub, never another lens. Generative artifact production for the /agentic play; direct-model-write per ADR 026 — writes only the per-node lens doc to the live model and NEVER a shared file (spine/profile/decisions).
version	0.5.0
user-invocable	false
model	opus
allowed-tools	Read, Write, Bash, Glob

author-agentic-lens

Turns a shaped slice's hub — the grounding docs of the functionalities it bundles, plus the product profile — into the slice's agentic lens, written as the grounding doc agentic.md: whether the slice is (or contains) an agent at all, and if so how much human load it offloads on three axes and what controls bound it. A slice that should offload nothing comes out "not an agent" — a valid, common answer, stated plainly. It reads the hub only (never another realize lens).

Write discipline (ADR 026, standards/rules/direct-model-write.md). This is the LLM authoring skill of a direct-model-write play: it writes ONLY the per-node lens doc agentic.md straight to the live model (at lens_rel under product_base) — its own file, no draft copy. It NEVER writes a shared model file: the spine _spine.yaml, the profile, or a decisions/ record. Any material autonomy choice is emitted as structured data in the manifest (a non-model STM artifact); /agentic's deterministic keyed persist (persist_agentic.py) reads the manifest and writes the decision in place, keyed to the slice. Containment is /agentic's post-write scoped guard, not a draft.

What it produces (against the locked template)

agentic.md conforms to standards/schemas/product-os/grounding/lens/agentic.md — H1 # Agentic Lens, sections Is it an agent? (the gate + why), Load weights (a table: cognitive / creative / logistical on a low→ultra scale, with rationale; "n/a — not an agent" when the gate is no), Controls (guardrails, handoff; for a non-agent slice, the determinism boundaries). It must clear the linter (shape) and the content-quality eval (the play runs both) — run over the LIVE doc, since it is written in place. Alongside it, a structured agentic-manifest.yaml (written under STM) carries the machine-checkable grounding the prose can't — which functionalities the assessment is grounded in, the lens's live relative path (lens_rel), and any material autonomy decision as a full record (the keyed persist writes it in place).

Inputs

Field	Required	Description
slice_ref	yes	{domain}/{slice-id} — display reference.
slice_file	yes	Path to the live slice record (read-only — for the functionalities it bundles).
functionality_groundings	yes	Paths to each functionality's functionality.md grounding doc (the hub, resolved by check_ready_slice). Read these for behavior/acceptance — NOT ice.yaml (retired).
profile	yes	The product profile (from the spine) — conditions + surfaces. Read-only.
kb_search	yes	Path to the KB search script, for agentic-framing grounding.
kb_root	yes	Path to knowledge/, to resolve learning ids.
product_base	yes	Product model root — the lens is written IN PLACE under it; also read to reuse an existing autonomy decision.
lens_rel	yes	Relative live path of the lens: product-os/{domain}/slices/{slice}/lens/agentic.md. The doc is written to {product_base}/{lens_rel}.
manifest_path	yes	Output path under STM for agentic-manifest.yaml (the grounding map + lens_rel + any decision records).
proposals_dir	yes	Output folder under STM for any KB-learning-gap proposals.
stm_base	yes	From config.

Procedure

Reasoning (the agent verdict, the weight ratings, the controls) is yours. Template conformance, grounding, and honesty are non-negotiable.

1. Read the hub. Load each functionality's functionality.md (its behavior, rules, acceptance) and the profile. Do NOT read any other lens.
2. Decide the gate. Does this slice do agentic work — decide and act on its own toward a goal — or is it deterministic? State the verdict AND why, grounded in what the functionalities actually do. A deterministic read/compute slice is "not an agent"; say so — never manufacture an agent that isn't there.
3. Rate the weights (only if an agent). Cognitive, creative, logistical load offloaded, each on the low→ultra scale, with the rationale tied to the functionalities. If not an agent, write "n/a — not an agent" and explain.
4. Define the controls. Guardrails on any agentic behavior and the human handoff points. For a non-agent slice, the controls are the determinism boundaries that keep it predictable.
5. Write the lens in place + the manifest. Write agentic.md to the LIVE path {product_base}/{lens_rel} (per the template) — the per-node lens doc, straight to the live model, overwriting a prior lens on a re-run. Write agentic-manifest.yaml to manifest_path under STM: the functionalities the assessment grounds in, the lens_rel, and any material autonomy choice emitted as a full decision record under decisions: (structured data — NOT a file). Write any KB proposals under proposals_dir. NEVER write the spine, the profile, or a decisions/ file, and never another lens.

Output — the live lens + the STM manifest

{product_base}/product-os/{domain}/slices/{slice}/lens/agentic.md   # the Agentic lens grounding doc — WRITTEN IN PLACE (live)
{manifest_path}                                                     # agentic-manifest.yaml — grounding map + lens_rel + any decision (STM)
{proposals_dir}/<gap>.yaml                                          # KB-learning-gap proposals (only if gaps; STM)

agentic-manifest.yaml:

agentic:
  slice_ref: token-dash/slice-trusted-coverage
  lens_rel: product-os/token-dash/slices/slice-trusted-coverage/lens/agentic.md
  is_agent: false
  grounds:                                        # the functionalities the assessment considered
    - { source_type: functionality, source: "func-source-usage-ingest", functionality_ref: func-source-usage-ingest }
    - { source_type: functionality, source: "func-privacy-trust-labeling", functionality_ref: func-privacy-trust-labeling }
  choices: []                                     # KB-grounded agentic-framing choices (if any)
  decisions: []                                   # full autonomy decision records (only if a material choice) — the keyed persist writes them in place

Return the enriched contract with the lens_rel (the live doc) and the manifest_path — paths, never inline content.

Rules

• Hub only. Derive from the functionalities' grounding docs + the profile; never read or ground on another realize lens.
• Template-true. agentic.md conforms to the Agentic lens template (Is it an agent? / Load weights / Controls) and must clear the linter + the content eval — every item self-explaining.
• Honest gate. A deterministic slice is "not an agent"; do not invent agentic behavior. The weights table is omitted (n/a) when the gate is no.
• Cover the hub. The assessment considers every functionality the slice bundles, recorded in the manifest grounds.
• Grounded, not invented. The verdict and weights ground in the functionalities' behavior; any material autonomy choice grounds in a KB learning or a proposal and is recorded as a decision record in the manifest.
• Direct-model-write (ADR 026). Write ONLY the per-node lens doc agentic.md to the live model; never write a shared file (spine/profile/decisions) — emit any decision as manifest data. Containment is /agentic's post-write scoped guard.