opensquid 0.5.395

package/packs/builtin/pack-architect/SKILL.md

@@ -0,0 +1,74 @@
+# pack-architect
+
+opensquid's meta-discipline pack: **teaches users how to author well-formed
+opensquid packs**. Ships in dual-mode (`usage: both`):
+
+- **Active**: the 4 skills fire inline while you're editing pack-config
+  files (manifest.yaml / skill.yaml) and surface authoring checklists.
+- **Profession**: when another pack emits
+  `next_action.profession: pack-architect`, the agent spawns a
+  pack-architect subagent that walks you through a full 4-phase
+  pack-authoring session.
+
+## Opt in (NOT loaded by default)
+
+```json
+{ "packs": ["default-discipline", "pack-architect"] }
+```
+
+Per BR.1, opensquid never auto-imposes discipline. Add pack-architect to
+your `~/.opensquid/active.json` (or project-scope `.opensquid/active.json`)
+when you want it.
+
+Pack-architect works best when **scope-architect is also opted in** — the
+pack-scope-elicit skill emits chain-handoff directives to scope-architect
+for prework. Without scope-architect loaded, the MM.2 profession resolver
+will drop those directives + log them; the user's prompt is unaffected
+but the chain-handoff stalls.
+
+## The 4 skills
+
+| Skill                           | When it fires                                                                       | What it does                                                                                    |
+| ------------------------------- | ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
+| `pack-scope-elicit`             | UserPromptSubmit matches pack-authoring intent + the coding-flow FSM is null/`idle` | Emits directive `next_action.profession: scope-architect` for prework                           |
+| `manifest-author-walkthrough`   | PreToolUse Edit/Write of `packs/*/manifest.yaml`                                    | Surface verdict with manifest-field checklist (cites pack-runtime.md §1; incl. guards/fsm.yaml) |
+| `skill-yaml-author-walkthrough` | PreToolUse Edit/Write of `packs/*/skills/*/skill.yaml`                              | Surface verdict with skill-field checklist (cites pack-runtime.md §2 + skill-grammar-guide.md)  |
+| `fsm-author-walkthrough`        | PreToolUse Edit/Write of `packs/*/fsm.yaml`                                         | Surface verdict with FSM checklist (cites pack-fsm-architecture.md; coding-flow example)        |
+
+## The 4-phase pack-authoring workflow (when spawned as profession)
+
+1. **Identify scope + persona** — kind/usage decisions, detected_by
+   choice, activation_scope.
+2. **Write manifest.yaml** — required + recommended fields per pack-runtime.md §1.
+3. **Author skills** — one skill per rule kind; when_to_load + triggers
+   - rules + process steps; verdict choice; if: grammar discipline.
+4. **Side-files** — `fsm.yaml` if the pack has a stateful lifecycle (initial +
+   states + TOTAL transitions; auto-loaded by name → `pack.fsm`; pair with
+   `guards:`); team.yaml only if profession-mode; other side files as needed.
+
+## References
+
+- `docs/pack-runtime.md` — the authoritative reference pack-architect
+  cites throughout.
+- `docs/pack-fsm-architecture.md` — the all-levels FSM walkthrough (the
+  `fsm.yaml` lifecycle, the total-transition engine, `read_fsm_state`/`advance_fsm`,
+  and `guards:`); the companion for stateful/behavior packs.
+- `docs/skill-grammar-guide.md` — companion doc for the `if:` grammar.
+- `packs/builtin/default-discipline/` — canonical built-in with rich
+  foundation/detected_by populated.
+- `packs/builtin/scope-architect/` — canonical profession-mode-eligible
+  pack (chain-handoff target).
+- `packs/builtin/task-spec-author/` — canonical pure-profession pack.
+
+## Customizing
+
+The surface-verdict checklists can be too noisy for active pack
+authoring (every Edit fires). If that becomes an issue:
+
+- Move the skill to `load: lazy` + add a more specific
+  `when_to_load: chain_stage: ...` matcher
+- Or copy the skill into your own pack with a project-specific
+  `detected_by:` clause limiting WHEN it activates
+
+Pack-architect IS the canonical example of a well-authored pack — it's
+designed to be copied + adapted, not just consumed.

package/packs/builtin/pack-architect/manifest.yaml

@@ -0,0 +1,53 @@
+# pack-architect — opensquid built-in profession pack teaching pack authoring.
+#
+# MM.4 (2026-05-30). The pack-architect persona is the meta-discipline: it
+# walks users through authoring well-formed opensquid packs (manifest + skill
+# yaml + side-files). Ships as a profession (subagent-spawn capable) AND as
+# an active-loadable pack (skills fire inline when user is editing
+# pack-config files).
+#
+# Opt-in. NOT in default active.json per BR.1. Users opt in via:
+#   { "packs": ["default-discipline", "pack-architect"] }
+#
+# Per [[project_opensquid_personal_rules_are_user_codex]]: pack-architect is
+# teaching discipline, not personal evaluation patterns. It ships for
+# everyone but only loads when the user opts in.
+name: pack-architect
+version: 0.1.0
+scope: workflow
+goal: teach pack authoring — manifest + skill yaml + side-files + focused-vs-composite + active-vs-profession decisions
+description: |
+  Profession pack for opensquid pack-authoring discipline. Four skills
+  fire when the user is preparing or editing pack-config files:
+
+  - pack-scope-elicit: detects user mentioning pack authoring without
+    prior scope work; emits chain-handoff directive to scope-architect.
+  - manifest-author-walkthrough: fires on Edit / Write of any
+    manifest.yaml; surfaces the authoring checklist (fields incl. guards
+    + verify_gates + the fsm.yaml side-file).
+  - skill-yaml-author-walkthrough: fires on Edit / Write of any
+    skill.yaml; surfaces the when_to_load + triggers + rules +
+    process-steps (+ FSM-gating) decisions + cites skill-grammar-guide.md.
+  - fsm-author-walkthrough: fires on Edit / Write of any fsm.yaml; surfaces
+    the FSM lifecycle checklist (initial + states + total transitions +
+    guards) + cites pack-fsm-architecture.md (coding-flow is the example).
+
+  When SPAWNED AS PROFESSION (via directive
+  next_action.profession: pack-architect), the spawned subagent reads
+  docs/pack-runtime.md + the user's draft + walks them through a
+  complete pack-authoring session, producing a ready-to-ship manifest
+  + skill suite.
+
+  Foundation: this pack is the practical companion to
+  docs/pack-runtime.md. Pack-architect IS the doc, taught interactively.
+
+kind: focused
+usage: both
+evolves: true
+
+# Opt-in only — don't auto-fire even on installs. Skills inside each have
+# their own when_to_load matchers that gate firing further.
+detected_by: []
+
+# user = applies regardless of project (pack authoring spans projects).
+activation_scope: user

package/packs/builtin/pack-architect/skills/fsm-author-walkthrough/skill.yaml

@@ -0,0 +1,45 @@
+# fsm-author-walkthrough — surface an FSM-authoring checklist when the user edits any
+# pack's fsm.yaml (the pack-lifecycle side-file, auto-loaded by filename → pack.fsm).
+# Mirrors manifest-author-walkthrough / skill-yaml-author-walkthrough (one walkthrough per
+# pack file-type). The FSM layer is what makes a pack a BEHAVIOR pack — coding-flow is the
+# canonical example. Cites docs/pack-fsm-architecture.md (the all-levels FSM walkthrough).
+name: fsm-author-walkthrough
+load: preload
+when_to_load:
+  - kind: event_type
+    type: tool_call
+triggers:
+  - kind: tool_call
+rules:
+  - id: surface-fsm-authoring-checklist
+    process:
+      - call: tool_name
+        as: tool
+      # SG.2-fixed pattern: event path 'args.file_path' (not the binding 'tool_args...'),
+      # and len(matched) > 0 (matched is a string[]).
+      - call: text_pattern_match
+        if: 'tool == "Write" || tool == "Edit"'
+        args:
+          text_field: 'args.file_path'
+          patterns:
+            - 'packs/.+/fsm\.yaml$'
+        as: is_fsm
+      - call: verdict
+        if: '(tool == "Write" || tool == "Edit") && len(is_fsm.matched) > 0'
+        args:
+          level: surface
+          message: |
+            🔄 Authoring a pack FSM (fsm.yaml — the behavior lifecycle). Quick checklist
+            (cite docs/pack-fsm-architecture.md; canonical example: coding-flow/fsm.yaml):
+              [ ] initial (the start state)
+              [ ] states (every lifecycle state, explicitly listed)
+              [ ] transitions (each `{ from, on, to }`); the machine must be TOTAL —
+                  a non-matching event is an explicit stay (validateFsm enforces this)
+              [ ] gates: `guards:` in manifest.yaml (reusable detect→verdict templates)
+                  wire enforcement onto the transitions
+              [ ] skills drive the FSM via read_fsm_state / advance_fsm
+                  (cross-pack with `pack:`)
+              [ ] fsm.yaml is auto-loaded by filename → pack.fsm (it is NOT a
+                  manifest.yaml field)
+              [ ] FLOW templates expand into the machine before validateFsm (advanced;
+                  see docs/pack-fsm-architecture.md)

package/packs/builtin/pack-architect/skills/manifest-author-walkthrough/skill.yaml

@@ -0,0 +1,50 @@
+# manifest-author-walkthrough — surface a manifest-field checklist when
+# the user is editing any pack's manifest.yaml.
+name: manifest-author-walkthrough
+load: preload
+when_to_load:
+  - kind: event_type
+    type: tool_call
+triggers:
+  - kind: tool_call
+rules:
+  - id: surface-manifest-authoring-checklist
+    process:
+      - call: tool_name
+        as: tool
+      # SG.2 fix (2026-06-01): was 'tool_args.file_path' — a binding path
+      # text_pattern_match can't resolve → silent no-op. Event path
+      # 'args.file_path' fires.
+      - call: text_pattern_match
+        if: 'tool == "Write" || tool == "Edit"'
+        args:
+          text_field: 'args.file_path'
+          patterns:
+            - 'packs/.+/manifest\.yaml$'
+        as: is_manifest
+      # SG.2 fix: was 'is_manifest.matched == true' — `matched` is a string[],
+      # so `== true` never held even with a real match. Use len(...) > 0.
+      - call: verdict
+        if: '(tool == "Write" || tool == "Edit") && len(is_manifest.matched) > 0'
+        args:
+          level: surface
+          message: |
+            📋 Authoring a pack manifest. Quick checklist (cite
+            docs/pack-runtime.md §1 for field details):
+              [ ] name (kebab-case, no leading digit)
+              [ ] version (semver, e.g. 0.1.0)
+              [ ] scope (universal / domain / specialty / workflow / project)
+              [ ] goal (one sentence, destination-first)
+              [ ] kind (focused | composite — default focused)
+              [ ] usage (active | profession | both — default active)
+              [ ] activation_scope (project / user / hybrid / team / global)
+              [ ] detected_by (7 kinds; pick or leave empty for always-on)
+              [ ] foundation (tools / domains / methodologies — only for
+                  focused packs)
+              [ ] includes (only for composite packs; pack_id + semver
+                  range per entry)
+              [ ] guards (reusable detect→verdict gate templates — for FSM-gated packs)
+              [ ] verify_gates (declarative author gates)
+            If usage is profession or both, you ALSO need team.yaml. If the pack has a
+            stateful lifecycle, ALSO author fsm.yaml (a side-file, auto-loaded by name) —
+            see the fsm-author-walkthrough checklist.

package/packs/builtin/pack-architect/skills/pack-scope-elicit/skill.yaml

@@ -0,0 +1,44 @@
+# pack-scope-elicit — directive to scope-architect when the user mentions
+# pack authoring AND the workflow hasn't started scope work yet.
+#
+# Per [[project_opensquid_no_agent_loop]] opensquid does NOT invoke
+# scope-architect; it surfaces the directive on the next UserPromptSubmit
+# envelope and the AGENT spawns the subagent.
+#
+# Reads the coding-flow pack's lifecycle state CROSS-PACK (read_fsm_state with
+# `pack:`) — null/idle means no scope decomposition has happened yet.
+name: pack-scope-elicit
+load: preload
+when_to_load:
+  - kind: event_type
+    type: prompt_submit
+triggers:
+  - kind: prompt_submit
+rules:
+  - id: detect-pack-authoring-intent-without-scope
+    process:
+      - call: text_pattern_match
+        args:
+          text_field: prompt
+          patterns:
+            - 'write\s+a\s+(?:new\s+)?pack'
+            - 'author\s+a\s+(?:new\s+)?pack'
+            - 'create\s+a\s+(?:new\s+)?(?:opensquid\s+)?pack'
+            - 'build\s+a\s+(?:new\s+)?pack'
+            - 'new\s+opensquid\s+pack'
+        as: intent
+      - call: read_fsm_state
+        if: 'len(intent.matched) > 0'
+        args:
+          pack: coding-flow
+        as: stage
+      - call: verdict
+        if: 'len(intent.matched) > 0 && (stage == null || stage == "idle")'
+        args:
+          level: directive
+          next_action:
+            profession: scope-architect
+            rationale: >-
+              pack-authoring intent detected without prior scope decomposition.
+              Spawning scope-architect to produce a pre-research artifact before
+              pack-architect walks the user through authoring.

package/packs/builtin/pack-architect/skills/skill-yaml-author-walkthrough/skill.yaml

@@ -0,0 +1,52 @@
+# skill-yaml-author-walkthrough — surface a skill-field checklist when
+# the user is editing any pack skill's skill.yaml.
+name: skill-yaml-author-walkthrough
+load: preload
+when_to_load:
+  - kind: event_type
+    type: tool_call
+triggers:
+  - kind: tool_call
+rules:
+  - id: surface-skill-yaml-authoring-checklist
+    process:
+      - call: tool_name
+        as: tool
+      # SG.2 fix (2026-06-01): was 'tool_args.file_path' — a binding path
+      # text_pattern_match can't resolve → silent no-op. Event path
+      # 'args.file_path' fires.
+      - call: text_pattern_match
+        if: 'tool == "Write" || tool == "Edit"'
+        args:
+          text_field: 'args.file_path'
+          patterns:
+            - 'packs/.+/skills/.+/skill\.yaml$'
+        as: is_skill_yaml
+      # SG.2 fix: 'is_skill_yaml.matched == true' never held (matched is a
+      # string[]). Use len(...) > 0.
+      - call: verdict
+        if: '(tool == "Write" || tool == "Edit") && len(is_skill_yaml.matched) > 0'
+        args:
+          level: surface
+          message: |
+            🧩 Authoring a skill.yaml. Quick checklist (cite
+            docs/pack-runtime.md §2 + docs/skill-grammar-guide.md):
+              [ ] name (kebab-case)
+              [ ] load (preload | lazy)
+              [ ] when_to_load (load triggers — event_type / tool_match /
+                  prompt_match / cwd_match / path_match / command_match)
+              [ ] triggers (event kinds — at least one)
+              [ ] requires (optional AND-preconditions)
+              [ ] rules (≥ 1 rule; each track_check or destination_check)
+              [ ] Each rule's process: call / args / as / if / on_empty
+              [ ] FSM-gated skills: read_fsm_state / advance_fsm + guards: (see
+                  docs/pack-fsm-architecture.md)
+              [ ] if: grammar uses the documented operator set + helper
+                  functions per skill-grammar-guide.md
+              [ ] Final step emits a verdict
+                  (pass / block / warn / surface / directive)
+              [ ] For directive verdict: next_action is skill XOR tool
+                  XOR profession (exactly one)
+              [ ] No vendor model names anywhere (use model_alias)
+              [ ] No silent fail-open (every error path returns explicit
+                  verdict)

package/packs/builtin/pack-architect/team.yaml

@@ -0,0 +1,84 @@
+# MM.4 — Mode A team manifest for the pack-architect profession.
+#
+# Single-role profession (leaf-node per T-MULTIMODE L19). Self-references the
+# pack itself per the same Mode A pattern as scope-architect/task-spec-author.
+# model_alias `reasoning` resolves at spawn time via the user's models.yaml
+# (model-neutral per [[feedback_stop_haiku_drift]]).
+name: pack-architect-team
+roles:
+  - name: pack-architect
+    pack: pack-architect
+    model_alias: reasoning
+    handoff_signal: PACK_AUTHORING_COMPLETE
+    instructions: |
+      You are the pack-architect subagent. The parent spawned you to help
+      author a well-formed opensquid pack.
+
+      Your charter (4-phase workflow):
+
+      Phase 1 — Identify scope + persona.
+        - What does this pack KNOW? (foundation: tools / domains /
+          methodologies — populate or skip per pack purpose)
+        - WHEN should it auto-activate? (detected_by — choose from the
+          7 kinds: file_exists / dir_exists / file_match / file_glob /
+          memory_match / conversation_signal / user_pinned)
+        - WHERE does it apply? (activation_scope — project / user /
+          hybrid / team / global)
+        - What KIND is it? (focused = one persona; composite = aggregate
+          existing focused packs via includes:)
+        - What USAGE mode? (active = loads into parent agent's mind;
+          profession = spawned as subagent; both = either)
+
+      Phase 2 — Write manifest.yaml.
+        - Required: name (kebab-case), version (semver), scope (universal
+          / domain / specialty / workflow / project), goal (one sentence).
+        - Optional but recommended: description, foundation, detected_by,
+          activation_scope, kind, usage.
+        - Cite docs/pack-runtime.md §1 for every field.
+
+      Phase 3 — Author skills.
+        - One skill per discrete rule kind.
+        - skill.yaml fields: when_to_load (load triggers), triggers
+          (event kinds), requires (AND-preconditions), rules (the actual
+          checks — track_check or destination_check).
+        - Process steps inside each rule: call / args / as / if /
+          on_empty.
+        - Cite docs/skill-grammar-guide.md for the if: grammar.
+        - Emit verdicts: pass / block / warn / surface / directive.
+        - For directive verdicts: choose next_action (skill XOR tool XOR
+          profession). Most common is profession for chain-handoffs.
+
+      Phase 4 — Side-files (only as needed).
+        - fsm.yaml: the pack's behavior lifecycle (initial + states + TOTAL
+          transitions {from,on,to}), if the pack is stateful — auto-loaded by
+          filename → pack.fsm (NOT a manifest field). Pair with `guards:` in
+          manifest.yaml (detect→verdict gate templates) + read_fsm_state/advance_fsm
+          in skills. Cite docs/pack-fsm-architecture.md; coding-flow/fsm.yaml is the
+          canonical example.
+        - team.yaml: required if usage: profession | both.
+        - chat_agent.yaml: only if pack defines a custom chat agent.
+        - models.yaml: only if pack ships model aliases.
+        - drift_response.yaml: only if pack needs non-default drift policy.
+        - channels.yaml / notifications.yaml: only for channel-aware packs.
+
+      Discipline:
+        - Per BR.1: NEVER auto-add the pack to default active.json. Ship
+          as opt-in.
+        - Per [[feedback_stop_haiku_drift]]: never name vendor models in
+          any file. Use model_alias.
+        - Per [[project_opensquid_personal_rules_are_user_codex]]: don't
+          ship personal evaluation patterns as built-in packs (they
+          belong in user packs).
+        - Cite docs/pack-runtime.md + docs/skill-grammar-guide.md +
+          existing built-in packs (default-discipline / scope-architect /
+          task-spec-author) as the canonical examples.
+
+      Emit handoff_signal `PACK_AUTHORING_COMPLETE` followed by the path
+      of the finished manifest.yaml on a final line.
+
+      If you need scope-first prework BEFORE pack authoring (the user
+      hasn't decomposed the work yet), emit a chain-handoff directive
+      via the verdict + next_action: { profession: 'scope-architect',
+      rationale: 'pack-authoring requires prior scope decomposition' }
+      and STOP (the parent will spawn scope-architect first, then
+      re-spawn pack-architect).

package/packs/builtin/scope-architect/manifest.yaml

@@ -0,0 +1,43 @@
+# scope-architect — discipline pipeline as an opensquid built-in pack.
+#
+# Promoted from ~/.opensquid/packs/sangmin-personal-rules/skills/scope-decomposer/
+# (a 271-LOC user-pack skill with 7 rules) per T-DISCIPLINE-PIPELINE-COMPLETION
+# DPC.1 (2026-05-30). Split into 6 skills (one per rule kind) for per-skill
+# when_to_load precision + per-skill testability.
+#
+# The pipeline (when active) enforces:
+#   scope-intent prompt → pre-research artifact → task-spec-author invocation
+#   → 11-field spec → TaskCreate with metadata.spec → 7-phase per task → ship.
+#
+# Ships in the npm package; opt-in via the active scope's `active.json`:
+#
+#   { "packs": ["default-discipline", "scope-architect"] }
+#
+# NOT auto-loaded. Per [[project_opensquid_personal_rules_are_user_codex]]:
+# personal evaluation patterns stay in user packs; this pack ships the
+# structural discipline-pipeline scaffolding everyone can opt into.
+name: scope-architect
+version: 0.1.0
+scope: universal
+# MM.3 (2026-05-30) — `usage: both` makes scope-architect eligible for
+# either the active-load path (existing behavior — 9 skills fire on
+# prompt_submit/pre_tool_use) OR the profession-spawn path (when another
+# pack's chain-handoff directive emits `next_action.profession:
+# 'scope-architect'`, the agent spawns this pack as a subagent per the
+# `team.yaml` role). `kind: focused` is explicit that the pack owns its
+# own content (not a composite aggregator).
+kind: focused
+usage: both
+goal: ship scope-first authoring discipline — pre-research → task-spec-author → 11-field spec → 7-phase per task
+description: |
+  Discipline pipeline pack. Six skills enforce the scope-first authoring
+  workflow: scope-intent detection, inline-spec blocking without prior
+  pre-research, TaskCreate provenance requirement, scope-before-code gate
+  in automation mode, task-list-generated hygiene, and three chain-handoff
+  directives that route the agent through pre-research → task-spec-author →
+  TaskCreate → 7-phase per task.
+
+  The agent uses the pack by calling the task-spec-author profession pack
+  (sibling builtin) when scope-architect's chain-handoff directives fire.
+  Opt-in via active.json.
+evolves: true

package/packs/builtin/scope-architect/skills/inline-spec-block/skill.yaml

@@ -0,0 +1,56 @@
+# inline-spec-block — HARD gate. Blocks Write/Edit of a task/track spec into
+# TASKS.md or docs/tasks/ if NO companion pre-research artifact exists on disk.
+# Extracted from user-pack scope-decomposer rule `inline-spec-block` (DPC.1).
+name: inline-spec-block
+load: preload
+when_to_load:
+  - tool_match: Write
+  - tool_match: Edit
+triggers:
+  - kind: tool_call
+rules:
+  - id: block-inline-spec-without-research
+    process:
+      - call: tool_name
+        as: tool
+      - call: tool_args
+        as: targs
+      # Disk truth: does a companion pre-research artifact already exist?
+      # Guarded so the readdir only runs for spec destinations.
+      - call: path_exists
+        if: '(tool == "Write" || tool == "Edit") && (endsWith(targs.file_path, "TASKS.md") || contains(targs.file_path, "docs/tasks/"))'
+        args:
+          dir: docs/research
+          pattern: '*-pre-research-*.md'
+          # `{{targs.file_path}}` (interpolated) — NOT bare `args.file_path`, which the evaluator passes
+          # verbatim as the literal string, making path_exists resolve a nonsense path → false-block.
+          # `targs` is bound above (tool_args), so this is the Write/Edit's real absolute file path.
+          base_file: '{{targs.file_path}}'
+        as: research
+      - call: text_pattern_match
+        if: '(tool == "Write" || tool == "Edit") && (endsWith(targs.file_path, "TASKS.md") || contains(targs.file_path, "docs/tasks/"))'
+        args:
+          text_field: args.content
+          patterns:
+            - '###\s+(?:Task\s+[A-Z0-9.]+|#\d+)'
+            - '\*\*(?:Deliverable|Required skills|Acceptance criteria|7-phase)\b'
+        as: shapeWrite
+      - call: text_pattern_match
+        if: '(tool == "Write" || tool == "Edit") && (endsWith(targs.file_path, "TASKS.md") || contains(targs.file_path, "docs/tasks/"))'
+        args:
+          text_field: args.new_string
+          patterns:
+            - '###\s+(?:Task\s+[A-Z0-9.]+|#\d+)'
+            - '\*\*(?:Deliverable|Required skills|Acceptance criteria|7-phase)\b'
+        as: shapeEdit
+      - call: verdict
+        if: '(tool == "Write" || tool == "Edit") && (endsWith(targs.file_path, "TASKS.md") || contains(targs.file_path, "docs/tasks/")) && (len(shapeWrite.matched) > 0 || len(shapeEdit.matched) > 0) && research.exists == false'
+        args:
+          level: block
+          message: >-
+            BLOCKED: writing a task/track spec with NO pre-research artifact on
+            disk. Author docs/research/<slug>-pre-research-<date>.md FIRST, then
+            invoke the `task-spec-author` profession to produce the 11-field spec.
+            Inline-spec in TASKS.md / docs/tasks/ is forbidden. To proceed:
+            create the pre-research doc (the gate relaxes once it exists), or
+            deactivate scope-architect for a one-off.

package/packs/builtin/scope-architect/skills/pack-skill-authoring/skill.yaml

@@ -0,0 +1,83 @@
+# pack-skill-authoring — warns when authoring a user-pack skill yaml
+# without prior research-tool activity this turn.
+#
+# Per T-DISCIPLINE-PIPELINE-COMPLETION DPC.4 (2026-05-30): closes the gap
+# where today's 5-skill drift batch authored pack yamls without recall +
+# without reading existing skills. The skill files all turned out to
+# pattern-match SYMPTOMS instead of addressing CAUSES (user caught it +
+# all 5 dirs were removed). This gate would have surfaced the discipline
+# violation BEFORE the writes landed.
+#
+# Trigger: PreToolUse on Write or Edit targeting paths matching
+# `.opensquid/packs/.+/skill\.yaml$` (user-pack writes; built-in pack
+# writes happen in opensquid src tree at different cwd and are gated by
+# DPC.1's normal discipline).
+#
+# Check: session_tool_history filtered to [mcp__opensquid__recall, Read].
+# If count == 0, the agent is authoring on intuition not research →
+# warn.
+#
+# Verdict level: warn (soft surface, not block). Authoring a skill IS
+# substantive work that needs prior research; warn nudges + surfaces +
+# allows the write to proceed if the agent has context the gate can't
+# detect.
+#
+# Known over-trigger surface: test fixtures at test/fixtures/*-pack/
+# skills/* match the pattern too. Acceptable: fixtures should also
+# benefit from research; warn is soft.
+name: pack-skill-authoring
+load: preload
+when_to_load:
+  - tool_match: Write
+  - tool_match: Edit
+triggers:
+  - kind: tool_call
+rules:
+  - id: warn-pack-skill-write-without-research
+    process:
+      - call: tool_name
+        as: tool
+      # SG.2 fix (2026-06-01): was 'targs.file_path' — a binding path
+      # text_pattern_match can't resolve (it reads ctx.event fields only) →
+      # silent no-op. Event path 'args.file_path' actually fires.
+      - call: text_pattern_match
+        args:
+          text_field: 'args.file_path'
+          patterns:
+            - '\.opensquid/packs/.+/skill\.yaml$'
+        as: is_pack_skill
+      - call: session_tool_history
+        if: '(tool == "Write" || tool == "Edit") && len(is_pack_skill.matched) > 0'
+        args:
+          scope: current_turn
+          filter_names:
+            - mcp__opensquid__recall
+            - Read
+        as: research
+      - call: verdict
+        if: '(tool == "Write" || tool == "Edit") && len(is_pack_skill.matched) > 0 && research.count == 0'
+        args:
+          level: warn
+          message: >-
+            PACK-SKILL AUTHORING (DPC.4): about to write a pack skill yaml
+            with NO recall or Read calls this turn.
+
+            Per the workflow (spec → research → ask gaps → task-spec-author →
+            7-phase): authoring a skill is substantive work that needs prior
+            research — read existing skills in the same pack for shape, recall
+            the discipline rules the skill enforces, read the primitive
+            contracts the skill calls. Without that, you're authoring on drift.
+
+            This is the gate today's 5-skill drift batch (2026-05-30) would
+            have fired — built skills without research, all 5 turned out to
+            pattern-match symptoms instead of addressing causes. User caught
+            it + all 5 directories were removed.
+
+            Required next action: recall the relevant discipline + read the
+            existing skill files + then author. Warn surfaces but does not
+            block.
+prose: |
+  Soft gate. Fires only when both (a) Write/Edit targets a user-pack skill
+  yaml path AND (b) session has zero recall/Read tool calls this turn.
+  Test fixtures over-trigger (acceptable); built-in pack writes don't
+  match (handled by DPC.1 discipline + inline-spec-block).