Codex compatibility — canonical specification and feature inventory

[dean0x]

Codex compatibility specification

Single source of truth: this issue body owns the current specification, feature roster, decisions, gaps, and acceptance requirements. Evidence snapshots live in comments on this same issue. Update this body when decisions change; do not maintain a separate local PRD or audit as competing authority.

Status: compatibility discovery/design. Adding Codex alongside Claude Code remains the goal; implementation phases follow agreement on the remaining product choices. Last consolidated: 2026-09-08.

Recorded decisions

• D01 — Coexistence: add Codex compatibility while preserving Claude Code and shared Devflow knowledge.
• D02 — Authoring: retain Markdown Script and shared semantics with explicit harness targets.
• D03 — MDS upgrade direction (2026-09-08): include upgrading from 0.2.0 to the latest stable release, currently 0.4.2, in this specification. Complete the breaking-change migration and preserve existing Claude behavior before relying on the new baseline. This replaces the earlier recommendation to stay on 0.2.0.
• D04 — Scope: initially defer the dynamic graph Workflow runtime for Codex; separately decide standalone preference extraction.
• D05 — Documentation ownership (2026-09-08): save the specification and supporting evidence here in Codex compatibility — canonical specification and feature inventory #333; use “Codex compatibility” consistently.

Evidence on this issue

• Original discovery and source evidence archive (historical; superseded decisions are labeled).
• Complete inventory: part 1/4, part 2/4, part 3/4, part 4/4. Includes all source hashes, policies, and both compiler probe baselines.

Implementation readiness — reviewed 2026-09-08

Feature roster: comprehensive. Full Codex implementation: not ready yet. The MDS upgrade is independently specified; the host contracts below still need design closure and runtime evidence. Readiness evidence and probe cases.

Contract	Required before relying on parity
R1 Hooks	Ordered capture/scheduling, dedupe, trusted sources, supported payloads, timeout/cancellation and explicit failure behavior
R2 Deny lists	Enforced command/file boundaries across real tool paths; representative allowed/denied and failure fixtures; MCP assessed separately
R3 Rules	Actual instruction discovery/precedence, overrides, shared size budget, scope/shadowing and update timing
R4 Subagents	Proven role/context/model/permission selection, write effects, bounded concurrency, child lifecycle and result completeness
R5 Skill loading	Full required body/reference acquisition in workflows and roles; installed/enabled discovery is not preload; missing mandatory dependencies cannot become a pass
R6 Agent loading	Generated TOML, discovery, namespace, invocation and effective role identity verified together; task labels/file existence alone are insufficient
R7 Memory/charter	Complete bounded delivery, root/child isolation, startup/resume/compaction restoration, recursion guard and active-workflow/approved-plan handoff

G03/G04/G09/G10 now explicitly cover: 64 KiB memory input versus ~2,500-token hook spill; the charter's 4,096-character skip; AGENTS.override.md precedence and 32 KiB budget; non-blocking SubagentStart continue: false; root-only charter isolation; and replacing the slash-only recursion guard. Each needs an observable load/failure result.

Validate R1–R7 in one fixture: workflow → roles → skill/reference → restored context → deny checks → coexistence/uninstall. Record the client/version and evidence, settle open product choices, then approve broad implementation. Runtime integration remains untested.

The checked-in feature roster is fully reconciled with the registry. The gaps are mostly inside feature contracts: prompt bodies, skill activation, role permissions, process control, configuration ownership, and artifact consumers. Copying or renaming the existing files would leave substantial Claude-specific behavior in the Codex installation.

Persistence follow-up (2026-09-09): P01–P13 evidence and fixtures add requirements for exclusive/replay-safe learning, identity-preserving synthesis, active-turn/citation coverage, bounded corpus reads, memory validation/divergence, conflict-safe KB/index updates, valid scoped KB commits, and run-owned artifacts. Decide native-memory control/authority and worktree state/opt-out continuity, including detached HEAD. These extend R1–R7; the roster is unchanged.

Evidence and limits

• Audited Devflow 2.4.0 at 08fbdd4e37e0ec45a92279caf976822aea7a2e4c, branch feat/322-tracker-phase-0, initially clean. This is the same baseline as Codex compatibility — canonical specification and feature inventory #333. Remote main was still e726874729d9fdaf3aa6ceee4383b3ee72332fd6; the audit includes current tracker Phase 0 branch changes, not just released/main behavior.
• Readiness recheck: 23ea357 on 2026-09-08: all 258 asset paths retained; five assets revised. Carry forward degraded-fetch handling, normalized/dropped issue refs, feature-branch conventions commits, and ignore sentinel/user-entry preservation, plus newer test helpers. Counts remain unchanged; inventory hashes and original compiler measurements remain pinned to 08fbdd4. Details are in the readiness evidence.
• Local Codex CLI: 0.153.4. This is an observation, not a minimum supported version.
• Devflow's installed and pinned @mdscript/mds: 0.2.0. The sibling MDS repository describes the 0.4 language. The proposed upgrade target is 0.4.2, verified against npm and the release tag on 2026-09-08.
• Read Codex compatibility — canonical specification and feature inventory #333 and the September 7 issue-creation transcript, including its September 3–4 parent discussion. Preserve the decisions to add a second harness, keep MDS, and initially defer the dynamic graph runtime.
• Enumerated all 258 files under src/assets, scanned their contents for host assumptions, inspected every command's workflow surface and every agent/skill's metadata, and read the affected instruction blocks and runtime seams. Keyword findings were interpreted manually: for example, architecture's “LSP” means Liskov substitution, not a missing language-server tool.
• Inspected the registry, all public CLI registration surfaces, flags, manifests, installation paths, model configuration, hooks, workers, HUD assembly, and representative contract/packaging guards. The 96 TypeScript files under src are also enumerated in the inventory for follow-up ownership work; enumeration does not imply a line-by-line correctness review of every implementation.
• Fetched official Codex documentation on the audit date. Documented capabilities can exceed installed/client behavior; no paid agent runs, browser installation, hook installation, permission changes, or end-to-end Codex port were performed.
• Ran isolated MDS compilation probes and compiled all 13 existing MDS command entry points without writing their outputs into the repository. All 13 compiled with zero warnings. These are compiler checks, not workflow execution tests.
• The machine-readable inventory snapshots linked above record names, source hashes, ownership, host-reference locations, dispositions and probe results. “Shared” means a proposed reuse disposition, not validated runtime parity.

Complete roster at this baseline

Surface	Count	Coverage
Registry feature groups	21	All registry entries; compliance is separately feature-owned
Public workflow entry points	14	13 MDS commands and the copied release.md
MDS partials	11	Shared contracts and dynamic-runtime instruction fragments
Authored agent roles	16	Includes report writers, code writers, validators, and maintenance
Domain/methodology skill roots	41	40 registry-owned plus compliance
Skill reference files	116	Including browser procedures and report/publication templates
Compliance framework assets	12	Fragment + reference for each of 6 frameworks
Rule files	13	12 registry-owned plus compliance
Script/hook assets	35	Includes the charter, workers, shared helpers, HUD launcher, and redactor
Public CLI management commands	16	Includes reset, shadowing, status, and interactive configuration surfaces
Claude setting/flag entries	29	Each needs a Codex disposition, including unsupported ones
HUD component IDs	15	Duration exists but is absent from the active default layout
Git role operations	18	Full list below; operation-specific failure/publication contracts matter
Security deny entries	154	129 command patterns and 25 sensitive-read patterns
Ignore-pattern entries	142	Ordered source entries, including duplicates and mixed purposes

Registry-to-filesystem reconciliation found zero missing and zero undeclared commands, agents, skills, or rules, counting compliance's explicit feature ownership. The inventory also includes 3 Claude configuration/ignore templates, build/package/CI entry points, and the 120 existing test files as validation coverage references. Counts do not add across these overlapping runtime and product views.

The 21 registry entries are core-skills, plan, implement, code-review, resolve, debug, explore, research, release, self-review, bug-analysis, ambient, dynamic, typescript, react, accessibility, ui-design, go, java, python, and rust (all prefixed devflow-). Core skills and ambient are always installed. Dynamic and the eight language/UI groups are optional. Current installation makes all registry skills available independently of plugin selection, while agents and rules follow selected ownership. Preserve that policy unless explicitly changed.

Product features and comparable Codex implementation

“Adapter” below means a concrete implementation direction backed by a host primitive. “Probe” means required behavior is not established end to end. “Deferred” is a scope disposition.

Feature family	Behavior that must survive	Codex implementation and remaining gap
Installation and distribution	Recommended/advanced setup, user/local scope, selective plugins, HUD-only, reset, prior choices, new-feature adoption	Harness-aware CLI dispatch and owned target installation. Emit skills, role TOMLs, instructions, hooks/config. Choose direct installation versus plugin packaging; plugins are not proof of standalone role/instruction installation.
Upgrade and removal	Reinstall, migrations, renamed/deleted assets, overrides, selective/full uninstall, dry-run, keep-docs, orphan sweep	Manifest ownership keyed by harness and scope; shared asset references prevent one uninstall deleting the other harness's runtime. Preserve user edits and explicit opt-outs.
Skills and rules	Progressive disclosure, domain selection, reference lookup, skill/rule shadow/unshadow/list, compliance-owned assets	Render metadata and invocation instructions per target; compose persistent guidance into owned AGENTS.md sections. Keep explicit reference-loading contracts. Probe activation and duplicate-name behavior.
Workflow orchestration	Planning, implementation, review, resolution, debugging, exploration, research, releases	MDS-generated workflow skills with the same inputs, artifacts, role contracts, retry budgets, decisions, and results. Use Codex subagents and supported interaction tools.
Ambient mode	Charter, role routing, context passing, workflow selection, plan continuation	Generate Codex-specific persistent/session instructions and prompt reminders. Explicitly request delegation. Native plan acceptance needs an approved-artifact continuation contract.
Role settings and TUI	Model/effort selection, default/reset, saved inactive entries, installed/unknown state, terminal navigation	Target-specific catalogs, validation, persistence, TOML emission, and status labels. Native Codex models must not be treated as dormant because the Claude proxy is disabled.
Prompt/answer/assistant capture	Independently gated memory and learning queues, raw answer evidence, usage citations	Normalize host events with harness, root/agent/turn/tool identity. Adapt answer correlation; asynchronous question submission is not an answer.
Working memory	Queue claim/recovery, throttle, bounded refresh, staged write, checksum reconciliation, watchdog, drift banners, compaction backup	Shared queue/reconciliation logic plus a codex exec runner. Decide process ownership, model, permissions, and cancellation. Preserve the re-entrancy guard.
Learning	Background maintenance, observation lifecycle, anchored ADR/PF ledger, curation, confidence, usage evidence, archive/reset	Adapt the Learning role and launch directive; preserve the canonical log/ledger/rendered views. Its lifecycle differs from the detached memory worker.
Knowledge and conventions	Index discovery, full selected KB reads, relevance, write-back opt-out, scoped commits, learned naming/release process	Reuse .devflow/features, .devflow/conventions.md, and .release/RELEASE-FLOW.md. Translate file/Git operations and permissions. Knowledge loading and write-back have different gates.
Review/publication/traceability	Focus coverage, incremental state, prior resolutions, disposition statistics, debt tickets, CI, threads, release evidence, redaction, dedupe	Preserve shared schemas and Git operation contracts. Add run provenance and an explicit cross-harness marker policy. Consume the emerging tracker contract when it lands.
HUD	Git/state collectors, context/quota/plan data, costs, config counts, learning counts, update notice	Reuse components behind a normalized Codex data source. Native footer subset or companion-pane renderer; presentation and reliable active-thread binding remain decisions.
Security	Dangerous-command policy, sensitive-file handling, managed/user setup, safe-delete, secret redaction	Translate to verified permissions/exec policy/hooks. Separate file discovery from enforced read denial. Keep safe-delete's shell scope explicit.
External tools	Browser QA, web research, Skim/rskim, Semgrep/Snyk/CodeQL, shell/Git/gh, MCP	Capability checks and per-client tool bindings; unavailable infrastructure must produce an explicit coverage result.
Diagnostics and packaging	Debug toggles/logs, missing-dependency diagnosis, installed versus operational status, npm build/tarball/CI/docs	Target-aware diagnostics, packaged generated outputs and helper dependency closure, preserved executable bits, fixtures for both targets.
Dynamic graph features	Ticket waves, plan challenge, dependency scheduling, checkpoints, gates, integration branch, handoffs/budgets	Initially deferred for Codex; retain Claude output. Preference extraction is a separate decision.

Codex's documented building blocks are skills, custom agents, instructions, hooks, and headless execution. The adapters in this table are Devflow design proposals derived from those primitives and the source contracts.

Every workflow entry point

All in-scope commands require target-specific invocation, arguments, skill references, delegation, and result collection. Codex workflow skill names such as $devflow-plan are proposed names, not existing command registrations. Preserve natural-language arguments and flags in the workflow input; do not leave $ARGUMENTS as a promised Codex runtime variable.

Command	Complete behavior to carry forward	Specific adaptation or scope
plan	Single/multiple issue inputs, requirements discovery, exploration, gap lenses, scope gate, design, challenge, final approval, design document, PR description guidance, optional/compliance issue traceability	Translate question gates and built-in exploration roles; carry complete approved input/artifact across continuation. Track existing input-consumption defect #331.
implement	Task/issue/plan inputs; setup; single/sequential/parallel Code strategies; validation/fix; Simplify; Scrutinize; revalidation; Evaluate/fix; QA/fix; CI; PR; report; knowledge refresh; revalidation-only continuation	Preserve the individual retry counters and strategy-specific PR/CI ordering. model="haiku" and long-process instructions need adapters. Current CI exhaustion reports then continues; it is not a universal hard stop.
code-review	Worktree discovery/validation and sequential worktree processing; preflight; incremental/full diff; prior resolutions/convergence warning; 8 mandatory and up to 12 conditional focuses; file reports; synthesis; PR summary; head marker	Schedule within available concurrency instead of demanding 20 simultaneous spawns. Preserve each required focus and report. Resolve shared .last-review-head policy.
resolve	Review selection, legacy report fallback, bug-analysis fallback, explicit timestamp/path, external threads, triage completeness, duplicate handling, issue-fix batches, Simplify, validation/fix, push/CI, debt, thread resolution, publication, merge-readiness report	Preserve all 8 verdicts, failure/skip/degraded states, statistics schema, bounds, and sequential Git effects. Worktree skill path and role model literals require translation.
debug	Issue/description input, competing hypotheses, independent investigations, evidence confirmation, convergence, synthesis, root-cause report, offer-to-fix gate, optional fix/Simplify, KB update	Use explicitly independent Codex investigations; route nested exploration through the orchestrator when depth/capacity is unavailable.
bug-analysis	Incremental/full and --no-static; static scanners/SARIF; decisions, knowledge and recent plan criteria; security/functional plus conditional integration/usability analysis; report/synthesis/head marker	Preserve scanner availability/timeout/exit status and scope; Diagnose needs report writes. Resolve .last-analysis-head provenance.
self-review	Changed-file discovery, decisions/knowledge, sequential Simplify then Scrutinize, conditional validation, pillar/status/commit report, KB write-back	Keep role context and sequential gate order; replace embedded Agent and skill instructions.
explore	Question input, Skim orientation, 2–3 independent explorers, synthesis, follow-up questions, optional KB creation	Map Explore separately from the authored Skim role; preserve opt-in KB creation.
research	Codebase/external/market/competitor/technology modes, conditional Skim, 2–5 researchers, trust-aware synthesis, durable sources, follow-ups and optional KB	Translate web/file tools in both the Research agent and its loaded research skills. Research writes artifacts.
release	Learned release flow, preflight, version input/derivation, dry-run boundary, confirmation, validation, release/tag/publish, evidence/backlinks, improvements/report	Include the currently copied .md in generation. Preserve user release authority and operation-specific primary-effect failures.
dynamic-tickets	Initiative/spec → reviewed tickets, dependency/wave structure, tracking issue, acceptance contract	Deferred runtime. Shared ticket semantics remain inventoried.
dynamic-plan	Parallel per-ticket plan/challenge, acceptance criteria/test plan, cross-plan conflict critic, preference decisions, DECISIONS-NEEDED.md, human gate	Deferred runtime. Do not silently substitute a plain checklist for graph behavior.
dynamic-build	One ticket or waves, dependencies/checkpoints/handoffs, implementation/review/verification, integration-branch safety, retries/budgets, wave reporting	Deferred runtime. Keep _engine, _factory, _wave, and roster dependencies associated with this disposition.
dynamic-profile	Bounded cross-project transcript/Q&A/rule/feedback sampling, editable preference profile, dry-run	Scope decision. Its body requires no Workflow runtime, but imports a Workflow preamble. Codex needs a new session/question source and removal of that misleading preamble. Its current automatic consumer is deferred dynamic-plan.

The 11 partials are _compliance, _decisions, _engine, _factory, _knowledge, _plan_contract, _preamble, _publication, _roster, _ticket_template, and _wave. Include partials in the conversion and dependency inventory, including emitted fenced examples.

Every agent and its real execution contract

All 16 have Claude model metadata and skills: preload lists. Four also declare an explicit tools: field: Knowledge, Learning, Skim, and Test. Codex's documented role TOML requires name, description, and developer_instructions; role config can specify model/effort and other supported session settings. A role's settings can override spawn/default choices, so precedence must be tested rather than inferred. Custom agent configuration

Role	Behavior and output	Codex-specific work
Code	Implement/test/commit; issue-fix, validation-fix, alignment-fix, qa-fix; optional PR/handoff	Load required skills; replace Monitor protocol; resolve compliance capability; honor model mapping, worktree and Git authority
Design	Gap-analysis and design-review modes; structured judgment	Preload mode/knowledge/decision contracts; preserve supplied-context and output limits
Diagnose	Security/functional/integration/usability bug analysis; writes focus report	Permit owned report output without granting unrelated product-code edits
Evaluate	Request/plan alignment and scope assessment; reports fixes for Code	Preserve no-fix behavior and acceptance-criteria inputs
Git	18 local/remote operations with distinct write/publication contracts	Shell/gh or selected provider, scoped Git permissions, redactor, serialization, source/reference split
Knowledge	Writes KB and index; commits only owned knowledge paths; never pushes	Scoped file writes plus authorized Git operation; preserve non-blocking commit result
Learning	Claims queues, curates observations and anchored ledger through helpers	Lifecycle/lock recovery, per-harness model settings, shared helper paths and re-entrancy
Research	Five research modes, dynamic methodology loading, source trust labels, writes findings	Web/file capabilities and owned report output; built-in fallback is currently allowed when optional methodology fails
Review	Parameterized focus, six-step review, severity/confidence, prior-cycle awareness; writes report	Required role context, focus loading, project-instruction lookup, report writes, compliance capability
Scrutinize	Nine-pillar assessment; fixes and commits; PASS/FIXED/BLOCKED	Preserve fresh-review intent through an explicit context contract; needs code and Git writes
Simplify	Refines code while preserving behavior; commits changes	Replace CLAUDE.md authority lookup; keep project-specific conventions rather than promoting example TS/React preferences universally
Skim	rskim/Skim orientation; exact content when needed; compact handoff	Translate Bash/Read vocabulary and honor installed Skim behavior
Synthesize	Exploration/planning/design/review/bug-analysis/research synthesis; several modes write summary files	Keep mode-specific report schemas and owned report writes
Test	Acceptance scenarios, browser/server lifecycle, fixtures, evidence; no product fixes	Browser adapter, long-process adapter, temporary/build/fixture writes, explicit skipped coverage
Triage	Eight verdicts with issue-ID completeness and security gate; never writes/builds/tests	A genuinely read-only role; preserve decision evidence and duplicate validation
Validate	Discover/run build/typecheck/lint/tests; structured failure output; never fixes/commits	Builds may write outputs/caches despite the no-edit instruction. Define allowed side effects and real exit-status handling

Permission design cannot follow model tiers. Review, Diagnose, Research, and Synthesize write reports. Validate/Test execute tools with filesystem effects. Code/Simplify/Scrutinize/Knowledge commit. Default workspace-write protects .git, .agents, and .codex, including resolved worktree Git directories. Commit/install operations therefore need an explicit supported permission path. Protected paths

Candidate choices are scoped permission profiles for report paths, or read-only analysis agents returning results for a controlled artifact writer. Named profiles are currently beta and do not compose with legacy sandbox settings; require version-specific validation before choosing them. Permission profiles

Built-in Claude identities Explore and general-purpose are extra invocation dependencies, not two more authored agents. Translate their purposes explicitly. Also replace the charter's blanket assertions that subagents cannot delegate and see none of the conversation; context inheritance and depth are host/session contracts.

Every skill, rule, and reference dependency

All 41 skill roots contain both user-invocable: false and allowed-tools. Ten contain activation.file-patterns/exclude: accessibility, go, java, python, react, rust, test-driven-development, testing, typescript, and ui-design. Their source presence does not establish identical enforcement even across Claude versions; capture the intended selection behavior and test each target.

Do not translate user-invocable: false to allow_implicit_invocation: false. The latter disables automatic selection while leaving explicit invocation possible—the opposite control. Codex documents name/description discovery, optional invocation policy and dependency metadata, and explicit skill loading. Preserve domain skills' automatic applicability; exact hidden-from-picker behavior needs a supported mechanism or an accepted UX difference. Duplicate names can both appear; they do not merge. The initial catalog budget is 2% of the model context, with an 8,000-character fallback when the context window is unknown—not a universal 8,000-character ceiling. Skill behavior

Skill roster	Shared content	Target-sensitive content
accessibility, go, java, python, react, rust, typescript, ui-design	Language/UI patterns and references	Metadata, activation/exclusions, tool vocabulary, names/references
architecture, complexity, consistency, database, dependencies, documentation, performance, regression, reliability, security	Domain review criteria	Metadata and companion-skill references; keep domain examples intact
review-methodology	Six-step process, coverage, findings schema	Focus-to-skill map; referenced report template brands output as Claude Code
testing, test-driven-development	Behavioral testing and RED/GREEN/REFACTOR contracts	Metadata, activation, questions, cross-skill links
software-design, boundary-validation, patterns	Engineering and boundary patterns	Metadata, question/file tools, referenced detection procedures
dependency-research	Need/search/evaluate/adopt-or-build discipline	Contains a fenced Agent(subagent_type="Explore") call; route the investigation appropriately
gap-analysis, design-review	Design challenge criteria	Compliance load/active references and file-tool vocabulary
quality-gates	Nine-pillar methodology and report templates	Edit/write/run capabilities; role-specific permissions
qa	Acceptance scenarios and evidence	references/browser-testing.md hardcodes nine Claude-in-Chrome tools and shell/server lifecycle
research-codebase, research-external, research-market, research-competitor, research-technology	Research methods and evidence formats	Read/WebSearch/WebFetch instructions, network capability, reference/output paths
apply-decisions	Compact index → selected ADR/PF bodies and citations	Full-reference read mechanism; injected index/path/context contract
apply-feature-knowledge	Consume supplied KB context	Full-content loading and worktree paths
feature-knowledge	KB schema, organization and authoring	File tools; distinguish illustrative Claude integration examples from live host instructions
worktree-support	Worktree discovery, protected branches, branch filters and resolution	Invocation/name/path, shell/Git permission and worktree binding
docs-framework	Artifact naming, directory structure, report conventions	File tool vocabulary; keep shared artifact schemas stable
git	Git/publication safety, conventions and references	Companion references, generated provider operations, host-branded comment footer
compliance	Generic controls plus selected-framework composition	Feature ownership, metadata, five ${DEVFLOW_COMPLIANCE_*} composition tokens, installed references and activation lookup

The 13 rules are engineering, quality, security, reliability, accessibility, go, java, python, react, rust, typescript, ui-design, and compliance. Their core guidance can remain shared; selected rules become owned persistent instructions in Codex. The compliance rule additionally has composition/stamping tokens. Preserve overrides, existing instruction files, discovery order, and size budgets.

All 116 skill references and 12 framework files have individual inventory entries. Three particularly easy-to-miss reference adaptations are:

• skills/qa/references/browser-testing.md: browser operations and dev-server ownership/cleanup.
• skills/git/references/github-api.md: Claude-specific publication attribution.
• skills/review-methodology/references/report-template.md: Claude-specific report footer.

The framework pairs cover GDPR, HIPAA, PCI DSS, SOC 2, ISO 27001, and SOX. Preserve active-framework-only reference installation, generic-controls mode with zero frameworks, remembered selections after disable, shadow precedence, and metadata/ownership-aware uninstall. This audit concerns feature behavior, not a legal reassessment of those frameworks.

Hooks, processes, and hidden prompt sources

Prompt generation must cover the charter and shell-injected directives as well as commands/agents/skills. session-start-context emits an Agent(... Learning ...) instruction and has its own opus/sonnet/haiku allowlist. preamble recognizes Claude's literal accepted-plan message and slash-prefix recursion guard. Neither is corrected by compiling workflow files alone.

Assets (all 35 accounted for)	Disposition
capture-prompt, capture-question, capture-turn	Event/schema adapters feeding shared queues; preserve independently gated consumers and usage scan
session-start-context, session-start-memory, session-start-orchestrator, preamble, assets/orchestrator-charter.md	Generate target prompts/envelopes; preserve context, learning launch and approved-plan semantics
memory-worker, background-memory-update, pre-compact-memory	Shared reconciliation with target runner, lifecycle and compaction adapters
ensure-proxy	Claude routing lifecycle; no required role in native Codex support
run-hook, hook-bootstrap, hook-log-init, debug-trace, log-paths, hud.sh	Host/OS/configuration/launch adapters
ensure-devflow-init, ensure-root-gitignore, resolve-project-root, get-mtime, git-marker, is-hex-sha	Shared project/Git/platform utilities; preserve root/worktree/ignore semantics
queue-append, learning-lock, json-parse, json-helper.cjs, decisions-usage-scan.cjs	Shared mechanics; version queue identity/schema where necessary and preserve usage evidence
lib/decisions-format.cjs, lib/mkdir-lock.cjs, lib/project-paths.cjs, lib/render-decisions.cjs, lib/safe-path.cjs, redact-secrets.cjs	Shared formats, locks, paths, renderer and redaction; audit packaged dependency closure

Concrete gaps:

1. capture-question rejects any tool_name other than AskUserQuestion and indexes answers by question text. A Codex event normalizer must correlate its actual request/result IDs and submitted answers; changing only the registered matcher produces zero captured answers. Cancellation, free text, multi-select, async delivery and errors need fixtures.
2. Capture/worker registration order is insufficient: Codex runs matching hooks concurrently. User/project/plugin hooks accumulate rather than replacing one another. Use one ordered dispatcher for capture-then-schedule and dedupe repeated event deliveries.
3. Hook tool names are not a simple textual translation table. Current docs explicitly alias unified exec_command to Bash, spawn_agent to Agent, and patch edits to Edit/Write; patch input is still a command/patch payload. Hosted tools are outside this path, and later stdin interaction does not repeat pre-tool checks.
4. Parent/child identity differs: subagent hooks can share the parent session_id. Include child and turn identifiers before queue dedupe or learning suppression.
5. Async hooks are session-bound and can be canceled at exit. Preserve detached memory recovery separately from Learning-agent lifetime. Inventory Interrupt and SessionEnd for cleanup/capture, as well as startup, prompt, tool, stop and compaction events.
6. The memory subprocess hardcodes claude -p, a Claude model, bypass flags, logging and watchdog assumptions. A Codex runner needs explicit auth/model/config and staged-output handling. Do not silently inherit unrelated plugins/hooks and recursively spawn maintenance.
7. “No subprocess”/“use the Read tool directly” instructions in knowledge loading and Skim need contextual adaptation where the client exposes file reads through shell tools. Preserve the prohibition on inventing model workers; do not forbid the only available file-read mechanism.

The factual hook constraints above come from the current hook contract. They still require fixtures on the minimum supported version. An App Server worker can pass an explicit skill input to request full skill injection; that does not prove preload behavior for interactive custom roles. App Server skills

CLI, settings, state and Git operations

All 16 management commands must address the selected harness where they affect installation/configuration:

CLI command	Surface to preserve
init	Scope, plugin selection, recommended/advanced, every feature toggle, security location, compliance selection, HUD-only, reset, prior-choice adoption
uninstall	Scope, full/selective, dry-run, keep-docs, shared/user-content cleanup and orphan reporting
ambient	Enable/disable/status; charter and handoff wiring
memory	Enable/disable/status/queue clear
learning	Enable/disable/status/list/configure/clear/reset; confidence and observation counts
knowledge	Enable/disable/status/list; toggle affects write-back
skills	Shadow/unshadow/list; full reference tree and generated source precedence
rules	Shadow/unshadow/list, enable/disable/status
agents	TUI/list/set model/set effort/reset/confirmation; installed/saved/unknown state
flags	TUI/list/status/enable/disable/set/unset; typed neutral/explicit/unknown states
hud	Enable/disable/status/detail setting; current detail setting has no rendered tool/agent rows
security	Status/enable/disable and user/managed scope
safe-delete	Enable/disable/status, shell install ownership
proxy	Enable/disable/status/port and remembered configuration; keep Claude-specific routing
compliance	Enable/disable/status/set frameworks, including empty set and remembered disabled state
debug	Enable/disable/status and correct log location

capture.ts and context.ts are wiring helpers, not additional public CLI commands. Interactive init also owns publication/attribution decisions; they must survive target selection even though they are not separate top-level commands.

Flag(s), covering all 29 entries	Codex disposition
default-model	Codex model config; validate against its catalog and selected account/provider
max-concurrent-subagents	Supported concurrency configuration, with bounded scheduling and capacity detection
forked-subagents, subagent-spawn-depth, agent-teams	Separate context, nesting, and collaboration contracts; no blanket equivalence
always-thinking, disable-adaptive-thinking	Reasoning controls where supported; retain provider-specific semantics as differences
brief, thinking-summaries	Model verbosity/reasoning-summary candidates; model support and display differ
show-turn-duration	Client UI setting if verified; otherwise explicit unsupported disposition
subprocess-env-scrub	Shell environment policy plus worker environment handling; verify coverage
disable-nonessential-traffic	Explicit telemetry/privacy configuration; no single assumed equivalent switch
suppress-attribution	Shared Devflow output preference plus verified native attribution controls
clear-context-on-plan	Approved-plan artifact and continuation contract; exact automatic transition requires probe
enable-todo-tools	Plan/checklist progress; task graph semantics are separate
tool-search, lsp	Capability discovery and verified tools/MCP; no undocumented setting emission
disable-bundled-skills, disable-git-instructions	Verified skill controls and instruction policy where available; no blanket host-system-prompt removal
disable-compact, disable-autoupdater	Host lifecycle behavior; do not equate an auto-compaction threshold with a proven disable switch
tui, view-mode, spellcheck	Client-specific UI; explicit unsupported disposition until an equivalent is established
prompt-caching-1h, pin-sonnet-4-6, disable-1m-context	Claude/provider-specific; no literal Codex configuration mapping
workflow-size-guideline, goal-checkin-minutes	Dynamic-runtime controls deferred; native goals would require a separately specified contract

Configuration candidates above refer to the Codex configuration reference. Do not write unsupported Claude keys into Codex TOML.

State design must cover more than manifest.json: agent-models.json, learning model/debug configuration, HUD configuration/cache/cost history, flags and provenance, proxy state, .devflow/config.json, knowledge/decisions/queues/locks, review/analysis markers, conventions, and preference profiles. The model layer currently defines external models as the complement of Claude names and makes them dormant without the proxy; that rule must live in the Claude adapter. Learning has a separate model allowlist in both TypeScript and injected shell text. Model dormancy source

The Git role's 18 operations are: ensure-pr-ready, validate-branch, setup-task, fetch-issue, fetch-issues-batch, post-review-summary, manage-debt, check-ci-status, create-release, gather-release-evidence, learn-conventions, fetch-review-threads, resolve-review-threads, post-resolution-summary, check-merge-readiness, backlink-shipped-issues, ensure-traceable-issue, and post-wave-report. Preserve bounded API work, marker dedupe, owned-path commits, body-file publication, redaction fallbacks, and the distinction between primary-action failure and optional traceability degradation. post-wave-report currently belongs to the deferred dynamic consumer.

Shared review artifacts create a specific coexistence decision: .last-review-head and .last-analysis-head contain a SHA, not harness/capability provenance. A Claude run can make Codex skip reviewing that same head. Reports can remain cross-readable while execution markers record harness, contract version, focus coverage, and commit; alternatively shared markers need an explicit equivalence policy. Do not accidentally change that behavior through path reuse.

HUD, browser and security gaps

HUD component	Codex direction
directory	Session/worktree binding
gitBranch	Shared Git collector, preserving dirty/staged semantics
gitAheadBehind	Shared upstream comparison
diffStats	Shared merge-base plus working-tree calculation; native committed delta differs
releaseInfo	Shared tags and commits-since-release
worktreeCount	Shared worktree collector
model	Codex model/effort/context metadata
contextUsage	Normalized usage/window data; compaction-aware calculation
usageQuota	Actual quota windows/reset data; consistent used/remaining interpretation
todoProgress	Codex plan events; completion is observed, not guessed
configCounts	Codex config/skills/hooks/MCP/instruction discovery; configured versus loaded versus used
learningCounts	Shared decisions ledger counts
versionBadge	Devflow installed/latest version check
sessionCost	Account-dependent estimate/unavailable; stable dedupe and consistent weekly/monthly basis
sessionDuration	Session start time; not currently included in Devflow's active layout

The current renderer does not display tool/agent activity rows; detail is persisted but not consumed by the rendering path. Adding activity rows is extra scope, not required parity. The retained HUD references below were source-inspected in the earlier session; they were not installed or tested end to end in this audit.

Use stock tui.status_line for a native subset, or a companion tmux/cmux process to reuse the full Devflow renderer. The inspected/publicly documented interface does not establish arbitrary custom footer output. The companion needs refresh/resize/exit/fallback behavior and exact thread binding; “newest rollout” is insufficient. App Server supplies structured thread/plan/usage events, but a new server does not automatically subscribe to another running CLI. A read-only collector should not resume a thread just to inspect it. App Server

Browser QA has a concrete candidate: Microsoft's Playwright MCP documents Codex configuration and provides navigation, snapshots, forms, JavaScript evaluation, console messages, and tab management. These correspond to the operations in Devflow's browser reference. It also documents browser-profile contention across concurrent clients; choose isolated or distinct profiles where needed. The built-in browser is documented as unavailable in CLI/IDE, so it cannot be the universal QA backend. Codex browser availability

Keep the dev-server lifecycle contract: reuse existing servers, own only servers started by the run, bound readiness waits, preserve logs and exit status, and clean up owned tabs/processes. Validate login/session requirements independently of tool availability. Browser/scanner outages must be represented in acceptance coverage, not reported as successful testing.

For sensitive files, Codex's permission profiles provide a candidate for path/glob read denial. This is a more concrete route than treating AGENTS.md or an invented .codexignore as enforcement. Profiles are beta, platform-sensitive and distinct from legacy sandbox settings. MCP servers and hosted tools require their own boundary assessment. Translate dangerous-command patterns through real exec policies/permissions; hook aliases and shell wrappers make literal pattern copying insufficient. Rules, Permission profiles

The security template's individual deny entries and every non-comment ignore pattern are preserved in the machine-readable inventory. The command-policy categories include destructive deletion/disk operations, shell/interpreter wrappers, downloaded-code execution, privilege/accounts/permissions, process/service termination, network listeners/scanning, kernel/firewall/container escape operations, scheduled persistence, log/history erasure, credential metadata access, remote transfer, mining, system package installation, mounts and protected-system writes. Sensitive reads cover environment/secrets, cloud/SSH credentials, private keys and system account files.

Do not turn every ignore entry into an enforced read denial. The current .claudeignore mixes secrets with context-noise exclusions, including SQL files, lockfiles, .git, and .gitignore. Devflow's database/dependency reviews, Git workflows, and ignore maintenance need some of those files. Classify confidentiality requirements separately from discovery preferences. Safe-delete also needs per-shell startup validation: existing support spans zsh, bash, fish and PowerShell with platform-specific trash behavior.

Prior HUD projects and pinned Codex footer sources are preserved in the linked discovery archive and readiness-review evidence; no dependency selection is implied.

MDS solution: shared semantics, harness targets

Use harness targets (claude-code, codex) as the term. MDS does not require a new “worlds” language feature. Keep tracker provider (github, later jira/linear), client capabilities, install scope, and harness as distinct inputs; an issue tracker is not a harness.

The historical 0.2.0 probes are preserved in the inventory and readiness-review evidence. The active target and verified 0.4.2 requirements follow below.

Proposed authoring and generation contract

1. Keep domain behavior shared. Author workflow/role semantics once. Retain unchanged domain references as ordinary Markdown. Convert target-sensitive bodies to .mds explicitly; do not reinterpret every brace in every existing Markdown example.
2. Use semantic MDS helpers. Define helpers for skill loading, delegation, result collection, human questions, long commands, project instructions, capability lookup, and report attribution. Pass the harness/target descriptor explicitly through imported functions so dependencies are visible. Keep complex behavior in target-selected blocks rather than a word-replacement dictionary.
3. Validate target inputs in TypeScript. Reject unknown harness IDs/capability combinations. Separate build-time target values from execution-time task placeholders. Do not compile a user's actual task into distributed assets.
4. Generate metadata separately. Parse shared role/skill metadata into a typed representation. Emit Claude Markdown frontmatter or Codex TOML / skill YAML / optional agents/openai.yaml with proper serializers. Render role bodies into developer_instructions. Preserve required skill lists as verified load contracts, not unsupported TOML keys.
5. Select fenced instruction examples as whole blocks. MDS conditionals belong outside fences. Where dynamic values are required, emit the instruction from a helper in ordinary text/inline code. Do not expect interpolation inside a fenced Agent(...) example. Preserve literal runtime placeholders deliberately.
6. Cover all prompt sources. Include release.md, agent bodies, affected skill bodies/references, charter, memory-runner prompt, and Learning/plan-handoff strings currently embedded in shell. Avoid parallel independently maintained copies.
7. Separate build output from install choices. Build both target artifacts; resolve scope, user shadows, selected compliance frameworks, available tools, and user model/effort choices through the target installer. Shared raw shadows must be validated for the requested target; incompatible overrides need a clear result, never a silent Claude copy.
8. Preserve compliance's composition stage. Its ${DEVFLOW_COMPLIANCE_*} tokens are not MDS target variables. Define and test the stage order: select/validate source or override, render target-sensitive body while preserving composition tokens, compose selected framework content, emit/stamp target metadata, install. Under 0.4.2, single-brace tokens remain literal; verify that framework composition consumes only its own tokens after MDS rendering.
9. Make every emitted asset owned and reachable. Target output manifests track source/dependency hashes, destination kind, logical ID, owner, and required capabilities. An install missing a required generated role/reference fails clearly. Legacy/default output paths can remain compatible while the new resolver is introduced.
10. Preserve Claude behavior during the extraction. Record existing outputs and use byte comparisons for mechanical changes; record intentional semantic changes separately. Validate names, references, metadata schemas, literal placeholders, and forbidden live host instructions in all generated bodies and examples.

Illustrative helper using the verified target 0.4.2 syntax:

@define load_skill(harness, name):
@if harness == "codex":
Read the discovered Codex skill {{name}} and its required references.
@else:
Invoke Skill(skill="devflow:{{name}}").
@end
@end
@export load_skill

The caller imports the helper and emits {{load_skill(harness, "testing")}}. The build invokes:

const result = await compileFile(sourcePath, { vars: { harness: target.harness } });
if (result.kind !== "markdown") throw new Error("Expected a Markdown asset");
const body = result.output;

This illustrates one proven composition seam, not a complete production skill resolver. The actual helper should use the generated target namespace and discovered installed path/capability. A workflow should still receive runtime arguments, results, worktree, and selected skills explicitly.

Suggested output families are target-owned workflow skills/commands, role artifacts, skill trees, instruction fragments, and hook prompts. The existing build only permits dist/commands and the installer copies agents/skills from src/assets; extending only compileFile would therefore have no effect on those installations. Update asset resolution, packaging, model rewriting, shadowing, compliance convergence, and uninstall together with the generator.

Coordination with existing tracker work

• #323 already proposes src/core/mds-variants.ts, generated Git agents, source resolution, and a byte-identical plumbing phase. It explicitly pins MDS 0.2.0 and excludes speculative variant lists in that phase.
• #324 adds operation/provider generation and recursive reference installation with containment/atomic-overlay requirements.
• #325 introduces tracker selection and Jira/Linear. All three were open on the audit date.
• Agree one generator/asset ownership contract across this work. Do not introduce a competing compiler or inject Codex variants into Tracker Phase 1 — MDS plumbing, provably byte-identical #323's zero-behavior-change phase without an explicit scope revision.
• The MDS 0.4.2 upgrade is now the chosen planning direction. Reconcile Tracker Phase 1 — MDS plumbing, provably byte-identical #323’s explicit 0.2.0 pin with this decision before implementation; retain its byte-equivalence objective. Keep the upgrade mechanically reviewable apart from later Codex behavior changes.

Markdown Script 0.2.0 → 0.4.2 upgrade requirements

Target: exact @mdscript/mds 0.4.2, npm latest verified 2026-09-08; published 2026-09-03. Keep it a development dependency, update the lockfile and native/WASM dependency resolution, and record any later target change here. The Devflow package currently remains on 0.2.0; this section specifies the migration. Published release, versioned changelog.

Fresh probe of the actual published package

Installed 0.4.2 in an isolated temporary directory and ran it against the current 13 command hosts. All 13 compiled with zero warnings, yet all 13 outputs changed. The six checked helper families alone left 33 literal call sites instead of injected instructions. For example, self-review shrank from 10,637 to 5,205 output bytes, and dynamic-build from 64,616 to 28,409. These are broken unconverted outputs, not optimizations.

The new double-brace imported-helper fixture compiled correctly for both claude-code and codex. Separate probes confirmed legacy escaped braces remain in output, source YAML remains unchanged by runtime vars, and messages results have no output field. Both compiler versions used their native backend; WASM and platform coverage remain upgrade checks. Full per-command results are saved in the evidence inventory.

Breaking changes and Devflow applicability

Change	What this requires here
Interpolation uses {{name}} / {{helper()}}; old single braces become literal	Migrate the 13 command hosts and 11 partials, including imported function calls and interpolated parameters. A dependency-only bump silently loses instructions.
Old \{ / \} escapes are no longer consumed; literal double-opening braces use \{{	Remove obsolete escapes from execution-time placeholders where the old compiler consumed them. Preserve literal examples, shell/JS expressions, JSON and framework tokens. Never double every brace indiscriminately.
Compile results are a Markdown/messages discriminated union	Narrow result.kind === "markdown" before reading result.output in build-mds.ts and future generators. Reject unexpected messages output for Markdown/TOML-body assets.
@message selects messages output; mixed loose content is invalid; old compileMessages/format APIs were removed	No current live @message/removed-API call sites were found. Explicitly keep workflow/role assets in Markdown mode; do not introduce chat-message output accidentally.
Fence recognition and whitespace semantics changed	Check tilde/indented/blockquote fences, multiline prompts, tables and blank-line boundaries. Preserve output bytes where feasible; document any necessary reviewed differences.
Comparisons are type-strict; inherited frontmatter deep-merges	Validate target variables and future capability conditions. If using inheritance, serialize only intended target metadata; do not leak base-template build keys.
File options/check API and diagnostics are stricter	Keep compileFile file-relative; no basePath/unknown options. Account for synchronous validation errors and changed diagnostic types if consumed. Current direct compileFile(host.file) needs no option migration.
CLI discovery/watch output and lint/fix contracts changed	Devflow currently uses its own walker, so it need not adopt MDS CLI layout. If using the migration CLI, enumerate intended sources explicitly, inspect fixes and residual diagnostics, and do not assume hidden/underscore files were all migrated.

Rust/Python-only API changes, removed messages APIs, and bundler/watch changes have no identified current Devflow consumer. They do not justify unrelated code changes. The 0.4.1/0.4.2 release notes mainly concern Python packaging; the relevant language/API breaks span 0.3 and 0.4. 0.4.2 package API, language specification.

Upgrade acceptance

• Capture the old compiler’s 13 generated command outputs plus copied release.md, hashes and required semantic sections before editing. Include dynamic commands: their Codex deferral does not remove their Claude regression obligations.
• Apply the compiler’s migration assistance to isolated/controlled sources, review transformations, update syntax-sensitive fixtures/guards, and compare generated artifacts. Compilation success is insufficient; ensure helper expansion, compliance/knowledge/decision instructions, placeholders and report/publication contracts remain intact.
• Keep the existing golden/containment/escape checks meaningful. Add targeted guards for lost helper expansion and wrong output kind; never refresh goldens solely to hide missing instructions.
• Run build, targeted MDS/contract checks, required full/integration checks and package-install validation; cover native and WASM backends. Record known suite contention separately from upgrade regressions.
• Reconcile Tracker Phase 1 — MDS plumbing, provably byte-identical #323’s old exact 0.2.0 requirement with D03 while retaining its byte-equivalence intent. Record any sequencing change here and link the eventual upgrade work; do not start a separate competing specification.

Gaps requiring resolution before implementation

ID	Gap beyond the original broad inventory	Required disposition
G01	Body conversion is not wired for plain agents/skills/references, copied release command, or injected hook prompts	Extend generation and asset resolution across all affected content kinds
G02	Installed MDS versus sibling-spec syntax; raw frontmatter and fenced-block passthrough	Choose language baseline and typed metadata/stage contract
G03	All 41 skill visibility/tool declarations and 10 activation maps have different Codex semantics	Preserve implicit domain use; decide exact picker/activation differences
G04	Nested delegation, required skill loading, literal tool/model calls, context assumptions	Explicit host operation and role-context contracts; capability fixtures
G05	Report-writing and build-running roles cannot simply use a read-only sandbox	Define allowed effects per role; verify Git/report/build permissions
G06	Claude Monitor/background/watchdog procedure appears in ordinary agents, not only deferred dynamic commands	Codex long-command start/poll/completion/cancel adapter preserving true exit status
G07	Runtime compliance detection assumes a global Claude installation	Resolve installed/active capability for selected harness/scope; preserve framework composition
G08	Model dormancy and Learning's separate allowlists still assume Claude aliases/proxy	Target-specific settings/capability validation, honoring explicit preferences
G09	Capture requires answer-schema adaptation, child identity, ordered dispatch, and duplicate control	Versioned normalized events and crash/interrupt/async fixtures
G10	Hooks, workers, config and instruction layers have distinct trust/permission/lifecycle behavior	Observable installation health and documented worker ownership
G11	Cross-harness review/analysis markers can suppress a requested run	Decide marker provenance/equivalence while preserving report interoperability
G12	Browser procedures, publication footers, file-read restrictions and external tool assumptions live in references	Include reference trees and injected templates in conversion/validation
G13	Existing workflows allow several degraded/skip/continue paths	Define acceptance coverage and failure policy explicitly; do not invent a universal hard gate
G14	Current tracker/MDS work changes the same generation/install seams	Reconcile the shared generator design and landing baseline

Known source defects must also remain visible while porting: #328 publication containment-rule placement; #329 debt-table backfill mismatch; #330 unescaped table content; #331 unconsumed planning inputs. These were already filed, not new Codex regressions. #332 tracks suite subprocess contention. The core-to-Claude import described by #274 is still present in learning-tuning-config.ts.

Decisions for the product owner

1. Initial clients/platforms. Recommended discovery baseline: CLI on macOS/Linux, with desktop/IDE evaluated separately and cloud explicitly deferred. Client scope remains open; this is a recommendation, not an approved support promise.
2. Packaging and names. Recommend retaining devflow init as the full lifecycle owner and generating explicit namespaced Codex workflow skills. Decide whether the first distribution also uses native plugin packages. All 41 domain skills becoming visible is an explicit UX question; do not invert implicit activation to hide them.
3. HUD experience. Choose native subset, full companion, or selectable modes. Recommend selectable native/full modes if accepting tmux/cmux setup; exact stock-footer patching remains a separate choice.
4. Quality coverage. Decide which missing skills, browser/scanners, review focuses, or exhausted retries block completion versus produce accepted partial/degraded results. Recommend mandatory acceptance coverage never reports PASS when unexecuted; keep optional maintenance non-blocking.
5. Role execution boundaries. Choose report-writing agents with scoped effects or read-only agents plus controlled artifact writes. Preserve user permission policy and deliberate Git authority; do not default every role or worker to unrestricted execution.
6. Shared versus target state. Recommend shared knowledge/decisions/conventions and interoperable reports, with harness/run provenance on queues, telemetry and incremental markers, and per-harness model/install settings. Decide whether an equivalent review from either harness satisfies incremental coverage.
7. Preference extraction. Keep the three graph workflows deferred. Decide whether standalone dynamic-profile earns initial scope given its cross-project data surface and deferred automatic consumer.
8. MDS/tracker coordination. MDS upgrade direction is recorded in D03; remaining work is to reconcile Tracker Phase 1 — MDS plumbing, provably byte-identical #323/Tracker Phase 2 — contract/mechanics split (GitHub only) #324’s generation seam and acceptance text with 0.4.2. No new MDS language feature is required by the successful probe.

Minimum Codex version, exact browser package/version, and headless runner details should be selected from capability probes. They are engineering decisions to resolve against these product choices, rather than assumptions to bake into the inventory.

Verification contract for the eventual implementation

• Machine-check registry coverage and all emitted asset/dependency ownership; fail on missing roles/references and unaccounted newly added assets.
• Compile both targets; parse emitted YAML/TOML/JSON; validate names, paths, namespace references, composition tokens, literal placeholders and host-specific instructions even inside fences. Preserve unchanged shared references byte-for-byte.
• Exercise representative workflow fixtures: approved-plan continuation; multi-issue context; all mandatory review focuses under limited capacity; report-writer permissions; long silent build success/failure/cancellation; real submitted/canceled questions; partial QA; redaction failure; truthful CI/verification outcomes.
• Exercise install/coexist/upgrade/shadow/unshadow/uninstall/reset under local/global scopes, custom homes, conflicting skill names, protected configuration, hook trust changes and duplicate hook sources.
• Exercise shared-state contention: same repo/worktree from both harnesses, same SHA reviews, resumed/compacted threads, root/child hooks, duplicate events, stale workers, concurrent human edits, disabled features mid-run, and interrupted/ended sessions.
• Exercise HUD missing data/cost, quota semantics, active-thread binding, multiple worktrees, resize/exit and missing terminal backend; browser profile isolation and cleanup ownership.
• Run existing Claude behavior/contract checks, targeted Codex fixtures, and tarball installation checks. The audit's successful compilation does not substitute for these runtime tests.

The roster is complete for the recorded source baseline. Planning readiness depends on resolving or explicitly accepting G01–G14 and the product decisions above, then recording the agreed requirements and delivery links in this issue.

[dean0x]

Historical discovery snapshot. The current issue body is authoritative. This preserves the original discussion and research; later decisions, including the MDS upgrade direction, supersede historical recommendations.

Original September 7 discovery overview and retained source anchors

Purpose and status

Add Codex as another supported Devflow harness, alongside Claude Code. Preserve Devflow's engineering workflows and shared knowledge while implementing the appropriate integration for each host.

This issue is a living discovery overview and input to a future PRD/design, not an approved implementation plan. It captures the feature inventory, possible Codex implementations, evidence, limitations, and decisions from the original discussion. Do not turn it directly into implementation phases or assume every proposed mapping has been tested.

The next work is to refine this overview against current Devflow and Codex, resolve the open decisions, and agree the PRD. Only then break delivery into phases and implementation issues.

Evidence baseline

• Inventory inspected on 2026-09-07, Devflow 2.4.0, commit 08fbdd4e37e0ec45a92279caf976822aea7a2e4c.
• Local Codex CLI reported 0.153.4. This is an observation, not a chosen minimum supported version.
• Earlier HUD research inspected Codex 0.153.0 source and third-party HUD source around 2026-09-04. Those projects were inspected, not installed or validated end to end in Devflow.
• Official documentation was refreshed on 2026-09-07. Documentation can describe newer behavior than an installed binary; version-specific fixtures and runtime probes remain necessary.
• Existing code and registry are authoritative where README prose has drifted. This snapshot contains 21 plugin registry entries, 16 authored agents, 41 skills, 13 rule files including compliance, and 14 command entry points. Recount when resuming.
• No existing Codex-specific issue was found by title search. Related ongoing work is listed below.

Decisions and insights to carry forward

1. Add support; do not replace Claude Code. Both targets should remain usable, including on the same machine and project.
2. Keep MDS. Markdown Script is a build-time prompt composition language. Codex consumes its generated Markdown; Codex does not need to execute .mds files. Harness-specific instructions and packaging still need adapting.
3. Always-on instructions are possible. Use Codex's instruction chain for persistent guidance. Do not conflate that with automatically reloading arbitrary files on each prompt, or with a dynamic Workflow runtime.
4. On-demand instructions are also possible. Skills and hook-injected context provide mechanisms for selective loading. Porting Claude's exact activation and precedence behavior is a separate question.
5. A full custom HUD is feasible. Existing projects collect Codex session data and render a companion terminal pane. The missing stock-footer extension point is narrower than “Codex cannot display our features.”
6. Defer the dynamic graph Workflow runtime for the initial scope, as discussed. Keep its features inventoried so the omission remains explicit. Do not interpret this as permission to remove them from the Claude target.
7. Do not promise universal one-to-one parity. Some features need an adapter, some require a companion process, and some exact host behavior is unavailable or unverified. Preserve the user outcome and document differences.

How to read the mappings

Status	Meaning
Native + adapter	Codex documents the required primitive; Devflow still needs target-specific generation/wiring. Not yet a Devflow implementation.
Shared + adapter	Most behavior belongs to Devflow and can reuse shared content/logic after host assumptions are removed.
Partial / probe	A plausible route exists, but exact behavior, data coverage, or lifecycle guarantees need verification.
No stock equivalent	The exact interface was not found in the inspected stock Codex version. An alternative may reproduce the outcome.
Deferred	Intentionally excluded from the initial scope, independently of technical feasibility.

1. Installation, distribution, and coexistence

Current entry points: CLI commands, Claude installer, registry, manifest, package/build.

Feature today	Proposed Codex implementation	Status / design question
Recommended/advanced init; user/local scope; selective plugin install; HUD-only mode	Add an explicit harness selection and a Codex target adapter. Retain existing setup choices where meaningful. Detect required capabilities/version and explain missing dependencies.	Shared + adapter. Exact CLI spelling, defaults, and per-harness configuration ownership remain open.
21 composable plugin selections and dependency-owned assets	Preserve the Devflow registry as the feature catalog; generate Codex-compatible installations from the selected entries.	Shared + adapter. Devflow registry “plugins” are feature groupings, not automatically Codex plugin packages.
Distribution through copied commands, skills, agents, rules, and scripts	Candidate A: direct skill/agent/config installation. Candidate B: generated .codex-plugin/plugin.json packages with skills, MCP configuration, and hooks, plus separately installed agents/instructions where needed.	Native + adapter. Choose packaging/granularity after validating lifecycle ownership. Plugin installation alone is not proof every required asset loads. Packaging
Global and repository scope	Use documented skill locations such as ~/.agents/skills and <repo>/.agents/skills; use Codex configuration/agent/hook locations in the selected scope. Honor configured Codex home rather than hardcoding all paths.	Native + adapter. Verify supported legacy locations, trust, precedence, and project-local provider restrictions. Skills, configuration
Shared runtime scripts in ~/.devflow; project state in .devflow	Keep canonical project artifact formats; identify the harness and session on transient events, locks, and telemetry.	Shared + adapter. Decide which caches, preferences, and models are shared versus per-harness.
Reinstall/upgrade preserving choices and overrides	Extend manifest ownership and migrations to identify harness, scope, generated files, and schema versions. Preserve explicit opt-outs and user edits.	Shared + adapter. Existing manifest assumes one target; do not let Codex setup overwrite Claude selections.
Full/selective uninstall, dry-run, keep-docs, orphan sweep	Remove only assets and config entries owned by the chosen target. Retain shared assets while another installed target needs them.	Shared + adapter. Define reference/ownership rules before implementing cleanup.
Skill/rule shadowing	Resolve ~/.devflow/skills and ~/.devflow/rules overrides before Codex generation.	Shared + adapter. Decide shared versus target-specific shadows. Validate rather than copying Claude-only frontmatter/tool names.
Hook trust and installation health	Report configured, trusted, loaded, disabled, and unsupported states separately. Provide the native review path for new/changed hooks.	Native + adapter. An installed but untrusted hook must not be reported as an operational Devflow feature. Hooks
Build, npm packaging, fixtures, update badge, docs/site	Package both targets; preserve Claude artifacts; add Codex generation and installation coverage. Explain the supported client/OS matrix and target-specific UX.	Shared + adapter. Current npm files list specifically includes Claude templates; Codex assets need explicit distribution coverage.

Client boundary: Start discovery with local Codex CLI, because that is what the HUD research establishes. Decide desktop/IDE/cloud support independently. Current docs distinguish plugin availability from standalone skill availability; do not advertise all clients as equivalent. Plugin availability

2. MDS, command entry points, and workflow contracts

MDS compiles composable templates to Markdown. Devflow's compiler currently discovers output-dir hosts and restricts output to dist/commands. The command sources contain Claude-specific Agent(...), Skill, $ARGUMENTS, tool names, paths, and model tiers. Merely copying compiled files will not translate those contracts.

Proposed direction: keep shared workflow semantics in MDS/partials, introduce target-aware authoring or generation for invocation/delegation/paths/models, and emit Codex workflow skills. Resolve target inputs at build/install time with whatever MDS API is verified; do not assume a harness variable already exists. Validate emitted frontmatter, imports, names, references, and required capabilities. The static release.md also needs coverage.

Codex skills provide explicit $//skills invocation and implicit description-based activation. Tentative names such as $devflow-plan are examples pending a namespace decision. Do not promise identical /plan or /devflow:plan command registration, and avoid collisions with Codex's own commands. Skills

Current workflow	Outcome to preserve in Codex	Mapping / qualification
/plan	Requirements discovery, exploration, gap analysis, design/challenge, human gates, durable design artifact, optional or compliance-required issue traceability	Shared + adapter: workflow skill delegates to Codex roles, reads/writes the same artifact contract, and stops at the same human decisions. Adapt argument parsing and interactive questions.
/implement	Issue/description/plan inputs; branch setup; Code → Validate → Simplify/Scrutinize → Evaluate → QA; bounded retries; PR and CI handling	Shared + adapter: explicit skill orchestration and Codex subagents, preserving ownership, gate order, output paths, and failure reporting. A successful spawn is not a successful gate.
/code-review	Up to 20 focus-specific reviews; mandatory and conditional lenses; confidence/severity; incremental diff/worktree support; consolidated report and PR publication	Native + adapter: Codex Review role per focus, scheduled within actual concurrency limits. Retain Devflow review semantics rather than substituting a single native /review.
/resolve	Blast-radius triage; FIX_NOW/FALSE_POSITIVE/BY_DESIGN/FIX_SEPARATE/TECH_DEBT/ESCALATED/DUPLICATE; fixes, validation, CI, debt tickets, deduped resolution report	Shared + adapter: preserve verdicts, bounded retries, publication, and traceability; translate tool/delegation calls.
/debug	Competing hypotheses, parallel independent investigation, evidence ranking, root-cause report, applicable knowledge write-back	Native + adapter: independent investigation roles plus synthesis. Keep diagnosis distinct from authorization to implement a fix.
/bug-analysis	Incremental/full static and semantic bug analysis, specialized Diagnose passes, persisted reports usable by resolve	Shared + adapter: reuse prompts and report schemas; probe availability of external analyzers and their tools.
/self-review	Simplify then Scrutinize, validation and applicable knowledge refresh	Shared + adapter: retain the sequential quality passes and explicit task boundaries.
/explore	Skim orientation, exploration, synthesis, optional feature KB creation	Shared + adapter: use shell/file tools, Skim if installed, and Knowledge role.
/research	Codebase/external/market/competitor/technology investigation with trust-aware synthesis and durable sources	Shared + adapter: use available Codex web/MCP/shell tools and return evidence-backed reports. Tool availability must be checked per client.
/release	Preflight, learned .release/RELEASE-FLOW.md, version/tag/publish sequence, release report	Shared + adapter: Git/Validate roles and shell tooling. Preserve release authority and project conventions.
/dynamic-tickets	Initiative → challenged tickets, dependency/wave structure, tracking issue	Deferred: current recipe depends on the Claude dynamic Workflow authoring contract. A Codex skill can potentially deliver ticket decomposition, but exact runtime parity is unverified.
/dynamic-plan	Per-ticket plan/challenge, preference-based decisions, DECISIONS-NEEDED.md, human gate	Deferred: same runtime distinction. Keep artifacts and behavior in the inventory.
/dynamic-build	Dependency-aware waves, checkpoints/handoffs, review/verification, integration-branch safety, wave reports	Deferred / no verified native equivalent for the inspected Workflow API (agent, parallel, pipeline, phase, workflow, budget). A separate runtime would be a new design decision, not an automatic port.
/dynamic-profile	Bounded, cross-project preference extraction into ~/.devflow/preference-profile.md	Partial / scope decision: source explicitly describes a plain agent operation requiring no Workflow runtime, despite importing the dynamic preamble. Could become an independent Codex skill with a session/question-source adapter. Preserve its opt-in privacy boundary and dry-run. It need not inherit the runtime deferral automatically.

Shared workflow requirements: human gates remain human gates; file/report contracts remain readable across harnesses; branch/worktree resolution is explicit; failed or missing mandatory review coverage cannot become a pass; Git writes remain serialized where necessary. The implementation detail may change, but these outcomes belong in the PRD.

3. Agents, skills, rules, and ambient orchestration

Feature today	Proposed Codex implementation	Status / gap
Authored specialized agent roster	Generate custom Codex agent TOML files containing role name, description, instructions, supported model/effort settings, and relevant config.	Native + adapter. Current docs use standalone ~/.codex/agents/*.toml / .codex/agents/*.toml; version-gate older registration formats. Subagents
Parallel work, result collection, follow-ups	Use Codex's spawn/wait/steer/close primitives through the supported host interface. Pass clear deliverables, paths, and constraints.	Native + adapter. Probe practical concurrency, depth, cancellation, result shape, and fresh versus inherited context. Do not copy the charter's blanket “subagents see none of this conversation” assumption.
Per-agent model and effort TUI/CLI	Keep devflow agents, render target-specific choices, and persist mappings for each target. Generate supported Codex role settings.	Native + adapter. Map analysis/execution/mechanical roles to available models; do not mechanically translate Opus/Sonnet/Haiku or silently override user choices. Probe precedence.
Agent skill preloading	Convert Claude skills: metadata into explicit, required skill/reference loading instructions or verified Codex configuration.	Partial / probe. Skill discovery is not proof that a role preloads every required skill. Test role-specific instruction acquisition.
Agent tool allowlists and permissions	Translate intent to supported sandbox, approval, MCP/tool settings and scoped execution boundaries.	Partial / probe. Claude tools: frontmatter is not a Codex schema. Natural-language restrictions alone do not establish enforced equivalence.
41 domain/workflow skills and reference material	Reuse skill bodies/references/assets with Codex-compatible metadata, names, paths, and tool instructions; preserve progressive disclosure.	Native + adapter. Audit descriptions for activation and catalog truncation; avoid duplicate visible skills after shadowing. Skills
12 general/language rules plus opt-in compliance rule	Compose selected, shadow-resolved guidance into owned sections of global/project AGENTS.md, or inject bounded context through an appropriate hook.	Native + adapter. AGENTS.md supplies persistent guidance; it does not promise rereading changes every prompt. Respect existing files, overrides, discovery order, and size limits. Instructions
Selective/dynamic rule context	Where needed, explicitly select relevant instructions in a skill or context hook.	Partial / probe. No verified identical Claude Markdown glob-rule activation contract. Current Codex .rules files are execution policies, not Markdown engineering rules. Execution rules
Ambient orchestrator charter	Generate a Codex-specific charter defining delegation, role routing, work ownership, and relevant workflow selection; load through the instruction chain or SessionStart.	Native + adapter. Codex can delegate when applicable instructions request it. Translate roles and inherited-context assumptions.
Per-prompt ambient reminder	Adapt the preamble behavior to UserPromptSubmit, preserve feature toggles and workflow-recursion guards.	Native + adapter. Determine which reminders are needed after validating the persistent charter.
Automatic plan-acceptance → implement handoff	Explicit approved-plan continuation that invokes the implementation skill with the full plan/artifact.	Partial / probe. Do not match Claude's literal Implement the following plan: text and claim Codex parity. Verify native plan/default transitions and supported trigger events; preserve manual invocation as a fallback.
Todo/task tracking	Map simple checklist progress to Codex update_plan; persist richer Devflow task state in artifacts if required.	Partial. A checklist is not a general persistent task graph, dependency scheduler, or Claude Agent Teams.

Roster to cover

Source: all 16 authored agents. These are role identities, not fixed model recommendations.

• Analysis/judgment: Design, Research, Review, Triage, Diagnose, Scrutinize, Evaluate, Learning.
• Execution/orientation: Code, Simplify, Skim, Test, Knowledge.
• Git/aggregation/validation: Git, Synthesize, Validate.

Also audit references to Claude built-in agents such as Explore and general-purpose; those are not additional authored Devflow agents. Preserve each role's permitted output and write behavior from current source, not just its model-tier grouping.

Skill and rule coverage

All 41 source skills must have a disposition; the shared adapter approach above applies to each:

• Language/UI: typescript, react, go, python, java, rust, accessibility, ui-design.
• Review/domain: architecture, complexity, consistency, database, dependencies, documentation, performance, regression, reliability, review-methodology, security, testing.
• Design/delivery/knowledge: apply-decisions, apply-feature-knowledge, software-design, docs-framework, git, boundary-validation, test-driven-development, dependency-research, gap-analysis, design-review, patterns, worktree-support, feature-knowledge, qa, quality-gates.
• Research: research-codebase, research-external, research-market, research-competitor, research-technology.
• Feature-owned: compliance.

Rule files: engineering, quality, security, reliability, typescript, react, go, python, java, rust, accessibility, ui-design, compliance. That is 13 files total (12 non-compliance + compliance); the README's count differs, so use the source inventory.

Registry nuance: current core comments specify universal installation of skills from all plugins, whereas rules follow selected plugins and compliance remains feature-owned. Preserve or explicitly revisit that behavior; do not accidentally change it through Codex package splitting.

4. Memory, learning, knowledge, and capture

Sources: hooks/workers, shared paths, knowledge partial, feature config.

Feature today	Proposed Codex implementation	Status / important invariant
User-prompt capture	Normalize UserPromptSubmit events into the existing memory/learning queue schema.	Native + adapter. Gate each queue independently; preserve session/turn identity and privacy.
Assistant-turn capture	Use Stop event text where sufficient; use a versioned rollout adapter for missing content.	Native + adapter / probe. Define treatment of commentary, final messages, retries, interrupted turns, and child-agent messages.
Answered-question capture	Map Codex interactive question requests/results into the same decision evidence as AskUserQuestion.	Partial / probe. Confirm exact tool/event coverage and response schema per client/mode; do not just rename the hook matcher. Never treat a displayed default choice as a submitted answer.
Queue identity and deduplication	Normalize harness/session/turn/tool-call IDs before appending; record provenance.	Shared + adapter. Resume, multiple sessions in one worktree, and parent/child hooks must not duplicate or cross-contaminate evidence.
Background working-memory refresh	Add a headless runner using codex exec or App Server. Feed a bounded prompt and capture a staged result for the existing reconciliation/commit logic.	Native + adapter. codex exec supports structured output and saved CLI auth; decide worker model, permissions, cancellation, and process ownership. Headless execution
Worker durability	Reuse queue claim/recovery, throttle, locks, staged output, checksum/CAS conflict handling, and success/failure markers.	Shared + adapter. Preserve concurrent human edits, stale-worker recovery, and re-entrancy guard. Replace hardcoded claude -p, model names, flags, and Claude-only session assumptions.
Startup/resume/clear/compaction memory restoration	Translate memory and git reconciliation into Codex context injection; preserve drift/stale banners and queue recovery.	Native + adapter. Validate each trigger and which file snapshot is authoritative.
Pre-compaction backup	Adapt PreCompact to the existing Git/working-memory backup behavior.	Native + adapter. Restore appropriately after compaction; preserve detached/unborn-branch handling.
Background Learning agent	Adapt the SessionStart learning directive to spawn a Codex Learning role, or choose a separately supervised headless worker.	Partial / probe. Current source requests a background subagent; it is distinct from the detached memory worker. Decide when learning runs and whether it must survive the parent session.
Decisions/pitfalls and observation lifecycle	Keep queues, anchored ledger, rendered decisions.md/pitfalls.md, index, usage evidence, archive/curation semantics, and tuning controls.	Shared + adapter. Do not replace the ledger with Codex native memories and lose IDs, scope, or lifecycle semantics.
Apply decisions during design/review/implementation	Load the compact index, then relevant entries; carry IDs/context into delegated work.	Shared + adapter. Runtime skill loading and child context must be verified.
Feature knowledge loading	Reuse index/frontmatter discovery, relevance matching, full selected KB reads, and verify-against-code behavior.	Shared + adapter. Current load is ungated; the knowledge toggle gates write-back. Preserve this distinction.
Feature knowledge creation/update	Codex Knowledge role writes KNOWLEDGE.md and index, then uses the current scoped commit protocol.	Shared + adapter. Preserve branch/worktree scope, only-owned-path commits, and non-blocking failure reporting.
Learned project naming conventions	Reuse .devflow/conventions.md and Git agent learn/use operations.	Shared + adapter. Keep separate from cross-project preference profiles and tracker-provider configuration.
Toggles and management CLI	Make memory, learning, knowledge, capture/context wiring, reset/drain behavior, and tuning work for the selected harness.	Shared + adapter. Disabling one target must not accidentally remove shared data needed by the other.
Sharing and ignore policy	Preserve current code's sharing of feature KBs and conventions; keep memory, learning runtime data, queues, locks, and transient docs local according to existing settings.	Shared + adapter. README's older blanket-ignore description has drifted. Use current ensure-root-gitignore/post-install logic, honor user overrides, and adapt Claude-specific ignore artifacts.

Hook constraints already identified

Codex documents SessionStart, UserPromptSubmit, Pre/PostToolUse, Pre/PostCompact, Stop, and subagent events. Hooks accept structured input and supported events inject additional context. Non-managed hooks require trust. Matching handlers run concurrently; async handlers can finish out of order and are canceled on session end. Tool coverage is incomplete for hosted/specialized paths, and transcript format is not stable. Hooks

Devflow design implications:

• Put capture-then-worker scheduling in one ordered dispatcher, or establish an explicit queue handoff; registration order is insufficient.
• Choose detached/supervised versus session-bound background processing based on required durability.
• Bound injected memory/charter output and detect truncation; a pointer to omitted content is not equivalent to having loaded it.
• Probe root/child IDs, question results, compaction restoration, and retries with actual supported-version fixtures.
• Preserve non-blocking optional maintenance without weakening mandatory workflow gates or security decisions.

5. HUD: preserve the research and separate data from placement

Sources: HUD entry point, components/layout, component IDs.

Claude invokes Devflow's renderer via statusLine.command and supplies JSON. Stock Codex's documented tui.status_line selects built-in identifiers. The inspected Codex 0.153.0 implementation uses a fixed item enum and a single-line renderer, with no equivalent arbitrary external-renderer callback. Configuration, pinned item enum, pinned renderer

Candidate presentation choices, not yet a product decision:

• Native subset: configure Codex's built-in footer items; minimal setup, limited styling and custom fields.
• Full Devflow HUD: reuse Devflow's renderer in a companion tmux/cmux pane, driven by a Codex session source. A terminal launcher/sidecar handles refresh, width, session binding, resize, exit, and fallback.
• Exact custom output inside the Codex footer: requires upstream support or a maintained source patch in the investigated approaches. Do not make a patched Codex binary the assumed default.

Devflow component	Native Codex footer at inspected baseline	Proposed full-HUD source / disposition
directory	Yes	Session cwd / launch binding.
gitBranch	Branch name; exact dirty/staged decoration differs	Reuse Git collector and current markers.
gitAheadBehind	No matching item found	Reuse Devflow comparison semantics and Git collector.
diffStats	Partial: committed branch delta	Reuse Devflow merge-base comparison, including working-tree changes and file count. Do not label the two calculations equivalent.
releaseInfo	No	Reuse latest-tag/commits-since-tag collector.
worktreeCount	No	Reuse Git worktree collection.
model	Model, reasoning, window size available	Session/turn metadata plus normalized model naming.
contextUsage	Percentage/window metrics; different presentation	Rollout token/window data or supported thread telemetry, rendered with existing bar. Validate context calculation around compaction and cached tokens.
usageQuota	Primary/secondary remaining percentages	Rate-limit windows and reset timestamps, normalized to used/remaining semantics; reuse bars/countdowns. Never invent a reset time or assume every plan has identical windows.
todoProgress	Task progress	Codex plan events mapped to completed/total checklist items.
configCounts	No	Codex config/instruction/hook/MCP/skill collectors. Distinguish configured, available, and observed-used skills; do not count unsupported files as loaded rules.
learningCounts	No	Existing Devflow decisions ledger counts.
versionBadge	Codex can show its own version, not Devflow updates	Reuse Devflow installed/latest version check and update notice. Decide visibility when native-only HUD is selected.
sessionCost + weekly/monthly totals	Conditional Enterprise thread estimate in inspected source	Partial / data gap: do not claim authoritative per-session dollars for all subscription sessions. API-mode pricing estimates must be labeled; rolling totals need stable session dedupe and one consistent cost basis. Hide/mark unavailable when absent.
sessionDuration	No matching item found	Session start timestamp. Component exists but is omitted from current default component list and layout groups; do not present it as currently visible by default.

Additional historical discussion covered tools, agents, and skill activity. Existing Codex HUDs demonstrate those collectors. Devflow currently parses tool/agent records but its main layout does not render tool/agent rows; treat adding those rows as an explicit scope decision, not required parity. The --detail setting needs a source audit rather than trusting old CLI wording.

Third-party implementations already researched

Project	Evidence worth retaining	Integration caveat
konnga/codex-hud	Closest feature/data-model match: context, quota/reset dates, Git, tools, skills, MCP, agents, plans, config counts, duration. Parser, state assembly.	Companion cmux/tmux pane; official Codex binary unchanged. MIT license file observed. Useful reference, not a selected dependency.
fwyc0573/codex-hud	Session discovery, incremental rollout parsing, tools/subagents, context and configuration display. Collector.	tmux launcher; active-session binding and multi-session behavior are substantial parts of the implementation.
Oh My Codex	Independent implementation of a HUD around Codex with pane lifecycle/reconciliation. HUD entry point.	Larger orchestration suite; do not adopt the entire suite merely to obtain a HUD.
anhannin/codex-hud	Explicit patch adding status_line_command.	Its inside-footer mode requires building a patched Codex. That config key is not evidence of stock support.
brandonwie/codex-hud	Another standalone HUD with an optional source-patch integration path.	Preserve as a secondary reference; recheck compatibility and license before reuse.

Common approach: bind the active session, consume ~/.codex/sessions/**/rollout-*.jsonl, normalize metadata/token/plan/tool events, and render outside the stock footer. “Newest rollout” alone is unsafe with concurrent sessions, resumed threads, worktrees, and subagents.

The documented App Server offers thread/tokenUsage/updated, plan/item events, and account/rateLimits/read. Evaluate it as a structured data source, including a shared-server launch architecture where appropriate. A newly started server is not automatically subscribed to an unrelated running CLI session; attachment and lifecycle need a probe. A read-only HUD must not resume/steer threads merely to inspect them. App Server

6. Security, external tools, compliance, and tracker integration

Feature today	Proposed Codex implementation	Status / gap
Dangerous-command deny patterns	Translate policy intent into Codex execution rules, sandbox/approval configuration, and verified synchronous tool hooks where needed.	Partial / probe. Claude Bash(...) wildcard rules are not Codex Starlark prefix rules. Test each policy category against real commands, wrappers, aliases, and supported execution paths. Execution rules
Sensitive-file protection and .claudeignore	Define separate requirements for retrieval exclusion, model instructions, filesystem access, and logs. Apply supported permission boundaries; suppress unnecessary discovery separately.	Partial / no verified identical ignore contract. .gitignore and AGENTS.md are not confidentiality enforcement. Do not create a fictional .codexignore counterpart.
User versus managed security mode	Map to supported user configuration and administrator-owned requirements/policies; surface constraints accurately.	Partial / probe. Respect managed settings and protected paths. Normal init must not claim administrator-level enforcement.
Safe-delete (rm → trash)	Reuse the shell helper where applicable or adapt an execution hook.	Shared + adapter / probe. Check noninteractive shell startup, direct binaries, command rewrites, and recoverability; a shell function is not a universal deletion barrier.
Secret redaction and PR-report publication policy	Reuse scrubber, visibility gating, auto/full/off, marker dedupe, and suppression on unavailable redaction.	Shared + adapter. Preserve counts-only public defaults and traceability-degraded reporting.
Compliance composition and framework selection	Reuse per-framework fragments and shadow semantics; generate Codex skill/instruction output. Keep diff-based activation and linked issue/design/review artifacts.	Shared + adapter. Six current selectable frameworks: GDPR, HIPAA, PCI DSS, SOC 2, ISO 27001, SOX. This is review workflow support, not a certification claim.
Git/GitHub operations and CI	Reuse Git role contracts with shell/gh or an explicitly selected tool provider. Preserve branch naming, PR creation, debt tickets, comments, dedupe, and CI evidence.	Shared + adapter. Keep permission boundaries and output formats; do not hardcode Claude MCP names.
Pluggable issue tracker work	Consume the emerging tracker contract behind the Git/workflow interface when it lands.	In-flight dependency: reconcile #321 and #322–#325 before freezing Codex design. GitHub is current baseline; Jira/Linear are planned work, not already verified support.
Learned release and naming conventions	Share existing files and operations across harnesses.	Shared + adapter. One harness must not overwrite another's conventions or infer an expanded publishing authorization.
Claude-in-Chrome browser QA	Port scenario instructions to a supported browser integration, e.g. an appropriately configured browser MCP, or native client capability where verified.	Partial / probe. Current Test agent lists mcp__claude-in-chrome__*; login state, browser profile, accessibility/DOM operations, and console inspection need explicit equivalents.
MCP integrations and tool discovery	Translate dependency/configuration, tool names, auth, and per-role availability.	Native + adapter. Declaring a server is not proving its tools are connected in CLI, desktop, IDE, or a worker.
Skim orientation and command rewriting	Retain explicit Skim/rskim instructions and adapt compatible pre-tool command rewriting independently.	Shared + adapter / probe. Audit shell aliases, hook input shape, output preservation, and nested/unified execution. Skim and MDS remain separate ecosystem dependencies.
Debug tracing and diagnostics	Keep devflow debug, per-project logs, capture/worker diagnostics, and scrubbed error reporting.	Shared + adapter. Put hook environment/configuration in the Codex target; distinguish unavailable telemetry from zero values and broken installation.
Existing Claude → GPT proxy	Continue supporting the current Claude routing feature. For native Codex, use supported Codex authentication/model configuration directly.	Target-specific. Native Codex must not require ANTHROPIC_BASE_URL or enabling the Claude relay. Reverse routing to Claude models is separate, unverified scope.

7. All current Claude-specific flags need a disposition

Source: 29-entry flags registry. Preserve saved Claude settings, expose only validated Codex settings, and report unsupported options explicitly. Similar labels are not proof of equivalent behavior.

Current flag(s)	Codex direction / status
default-model	Supported Codex model configuration; validate available models and target-specific persistence.
max-concurrent-subagents	Documented Codex concurrency setting; discover supported value/range and actual capacity. Do not copy Claude's default of 40 automatically.
forked-subagents, subagent-spawn-depth, agent-teams	Probe context inheritance, nesting, and collaboration separately. Native subagents do not establish identical team/task/mailbox behavior.
always-thinking, disable-adaptive-thinking	Map user intent to supported reasoning-effort controls where meaningful; no assumed exact algorithmic equivalent.
brief, thinking-summaries, show-turn-duration	Candidate verbosity/UI controls or workflow instructions; exact display and reasoning-summary parity unverified.
tui, view-mode, spellcheck	Host UI settings; no verified direct mapping. Keep unsupported flags hidden/identified rather than writing Claude keys.
tool-search, lsp	Probe Codex tool discovery and language-server integrations independently. No promise of identical built-in LSP tool surface.
prompt-caching-1h, disable-1m-context, pin-sonnet-4-6	Claude/provider-specific. No literal Codex translation; use supported model/cache behavior and explicit capability reporting.
clear-context-on-plan	Plan handoff/context lifecycle design from section 3; exact toggle unverified.
disable-bundled-skills, disable-git-instructions	Probe supported skill controls; Devflow instructions can express intent, but cannot silently disable undocumented host behavior.
subprocess-env-scrub, disable-nonessential-traffic	Translate security/privacy intent to Codex environment and telemetry settings plus worker environment filtering; verify coverage.
disable-compact, disable-autoupdater	Host-specific lifecycle controls; retain as unverified mappings until supported configuration is confirmed.
enable-todo-tools	Codex plan/checklist availability; richer task-tool parity remains open.
suppress-attribution	Preserve Devflow-generated commit/PR attribution preference in its Git contracts; native automatic attribution configuration needs verification.
workflow-size-guideline, goal-checkin-minutes	Runtime-specific; dynamic Workflow controls stay deferred. Native goals/check-ins, if used, require a separately validated contract.

8. Cross-cutting design direction to investigate

This is a proposed separation of responsibilities, not a finalized interface or request to build a framework:

• Shared product layer: workflow meaning, role instructions, skill/reference content, decisions/knowledge formats, compliance composition, Git/publication contracts, feature registry, and HUD components.
• Codex adapter: generated skills/agents/instructions, install/config/trust integration, tool vocabulary, normalized events and sessions, headless runner, model choices, and terminal rendering integration.
• Claude adapter: retain existing behavior and ownership. Audit core/CLI imports that currently assume targets/claude-code.
• Capability record: identify target/client/version and feature availability, including unsupported, disabled, missing dependency, and untrusted states. Feature parity should be observable, not inferred from copied files.
• Shared-state policy: decide how two harnesses operating in the same repo share knowledge while isolating transient session/cost/capture state. Reuse existing locks/atomic operations where sufficient; test cross-harness contention.

Avoid a second independently maintained copy of every workflow. MDS should make semantic changes propagate to both targets while keeping incompatible host mechanics explicit.

9. Gaps and decisions before a PRD can be approved

• Agree supported surfaces and operating systems: local CLI first, and explicit disposition for desktop, IDE, cloud, native Windows, WSL, macOS/Linux.
• Choose minimum Codex version from capabilities/probes, not the observed installation version.
• Choose install/namespace UX: direct installation versus Codex plugin packages, feature-group granularity, collisions, scope precedence, hook trust, and upgrade behavior.
• Define MDS target generation and audit every workflow/role for Claude-specific tools, arguments, paths, frontmatter, model names, and runtime assumptions.
• Verify custom role model/effort precedence, skill loading, context inheritance, write permissions, concurrency, and lifecycle control.
• Verify ambient routing and plan approval/handoff without relying on Claude's literal handoff message.
• Verify prompt/assistant/question capture, root/child IDs, retry dedupe, interrupted turns, compaction, and trusted hook behavior in each supported surface.
• Choose memory/Learning process ownership, model/auth configuration, background cancellation behavior, queue recovery, and cross-harness isolation.
• Choose native-only, companion HUD, or selectable modes; decide tmux/cmux dependency UX and read-only session binding. Do not treat exact footer patching as already accepted.
• Decide cost semantics and unavailable display; verify any Enterprise estimate access. Do not promise billing totals from tokens or quota percentages.
• Prove security-policy translations and sensitive-file behavior; resolve browser/LSP/Skim integration gaps and every flag disposition.
• Confirm initial dynamic-runtime deferral and separately decide whether preference extraction belongs in initial scope.
• Reconcile tracker work, current knowledge/sharing behavior, and overlapping adapter/installer refactors before writing final interfaces.
• Draft/update the PRD with explicit user outcomes, exclusions, acceptance scenarios, and accepted parity differences. Link its durable location here.

Future verification scenarios to carry into that PRD

• Clean Codex-only install; Claude-only regression; both harnesses in one repo; local/global overrides; partial install; upgrade/reinstall; uninstall one target without breaking the other.
• Execute each in-scope command/skill against a small fixture repo; prove delegation, required reviews, human gates, report paths, failure propagation, and publication contracts.
• Session restart/resume/compaction, two simultaneous sessions, worker crash, concurrent human memory edit, feature disable during processing, and duplicate event delivery.
• HUD resize/detach/exit, multiple threads/worktrees, missing/partial telemetry, quota semantics, unknown cost, and absence of a terminal backend.
• Security and redaction behavior using representative dangerous commands, sensitive paths, blocked permissions, and missing tools.

These are acceptance topics, not implementation phases and not a demand to write tests before the feature design is settled.

10. Keeping this overview and later PRD current

The issue body is the authoritative first-layer inventory until a linked PRD takes over detailed requirements. Preserve stable section/feature names when adding later issue links; keep unresolved facts visible.

When resuming work:

1. Re-read this issue and linked decisions; inspect current main, registry/assets, adapters, hooks/workers, HUD, and relevant in-flight issues.
2. Record the new Devflow commit, Codex version/client, and documentation/probe date.
3. Diff the feature inventory. Update changed mappings in this body and the PRD in the same planning revision; do not silently leave conflicting plans.
4. Record each changed assumption with evidence, affected features, and the replacement decision. Keep brief decision history rather than forcing readers to reconstruct the original chat.
5. Link the agreed PRD/design here. If an artifact lives in gitignored .devflow/docs, attach or copy its substantive content to a durable GitHub location; a local-only path is insufficient for future sessions.
6. Only after scope and acceptance criteria are agreed, create phases and implementation issues and link them back here.

Planning readiness: inventory reconciled; material mappings verified or explicitly accepted as partial/deferred; open product choices resolved; PRD linked and consistent. Creating this issue satisfies none of the implementation milestones by itself.

Drift already observed

• Prior discussion used Codex 0.153.0; local CLI now reports 0.153.4.
• Codex documentation currently describes hooks, custom agent TOML, and dynamically detected skill changes. Do not carry forward blanket claims that it cannot load instructions dynamically.
• dynamic-profile has a no-Workflow operational description despite including a Workflow-oriented shared preamble.
• Current Knowledge code commits scoped KB files; current Git-ignore code shares KBs and conventions and has a v4 marker. Older README/reference prose differs.
• Memory worker and Learning agent have distinct launch paths and durability semantics.
• HUD tool/agent data is parsed but not rendered as dedicated rows; duration is not in the default layout.

Related work

• Pluggable issue tracker (GitHub + Jira + Linear) — tracking #321, Tracker Phase 0 — harness first + live-defect fixes #322, Tracker Phase 1 — MDS plumbing, provably byte-identical #323, Tracker Phase 2 — contract/mechanics split (GitHub only) #324, Tracker Phase 3 — init-selected provider, background Tracker agent, Jira + Linear #325 — pluggable tracker and MDS/contract changes; recheck landing state before design.
• git.md: second size cut — move the 8 PR/review op bodies to references (SG-7) #326 — Git agent/reference split; affects where target-specific operations should live.
• arch: core module imports Claude Code adapter (ADR-013 crossing) #274 — reported core → Claude adapter dependency; verify whether still present before adopting its old diagnosis.
• feat: Multi-IDE Adapter Layer #125 — earlier multi-IDE adapter concept; related historical context, not a substitute for this feature-by-feature overview.

Sources and source entry points

Links below are sufficient to resume investigation without the original conversation. Devflow source links pin this inventory's commit; official documentation and third-party default branches may move.

Source anchors from the September 8 content audit

Finding	Source evidence at the audited commit
Existing build only emits commands	Compiler destination and invocation, asset lookup
Claude process protocol embedded in ordinary roles	Code long commands, Test, Validate
Hidden nested delegation and browser contract	Dependency research, browser reference
Global Claude compliance lookup	Compliance partial, copied release command
Report writers require file effects	Review output, Research output
Hook-injected model/delegation contract	Learning directive, charter
Answer matcher and text-keyed results	Question capture, answer extraction
Cross-harness incremental skip	Review marker, analysis marker
Existing degraded/continue behavior	Implementation CI budget, review optional skill fallback

[dean0x]

Evidence inventory, part 1/4. The current issue body owns the specification and decisions.

Machine-readable source roster and evidence — part 1/4

To reconstruct the complete inventory, read parts in order, merge fields into one object, and concatenate each named array from arrays. Source hashes refer to the recorded Devflow baseline. Historical 0.2.0 probes and the new 0.4.2 upgrade probes are distinguished.

{"snapshot":"devflow-codex-compatibility-2026-09-08","part":1,"parts":4,"fields":{"schemaVersion":1,"status":"Evidence snapshot for Codex compatibility specification; current issue body owns accepted decisions","auditDate":"2026-09-08","devflowVersion":"2.4.0","devflowCommit":"08fbdd4e37e0ec45a92279caf976822aea7a2e4c","devflowBranch":"feat/322-tracker-phase-0","remoteMain":"e726874729d9fdaf3aa6ceee4383b3ee72332fd6","codexCliObserved":"0.153.4","mdsPinned":"0.2.0","mdsSiblingSpec":"0.4","report":"Current body of GitHub issue #333; supersedes local audit and historical comments","scanCaveat":"Lexical references are search candidates, not individually proven incompatibilities. Generic Read/Write words and Liskov LSP are possible false positives. Full enumeration plus targeted semantic inspection is not a full correctness review.","counts":{"registryGroups":21,"workflows":14,"mdsCommandEntries":13,"mdsPartials":11,"agents":16,"skillRoots":41,"skillReferences":116,"complianceFrameworkFiles":12,"rules":13,"scriptHookAssets":35,"assetsTotal":258,"publicCliCommands":16,"flags":29,"hudComponents":15,"gitOperations":18,"typescriptSourceFiles":96,"existingTestFiles":120,"securityDenyEntries":154,"ignorePatternEntries":142}},"arrays":{"registry":[{"name":"devflow-core-skills","description":"Auto-activating quality enforcement skills - foundation layer for all Devflow plugins","commands":[],"agents":["learning"],"skills":["apply-decisions","apply-feature-knowledge","software-design","docs-framework","git","boundary-validation","test-driven-development","testing","dependency-research"],"rules":["security","engineering","quality","reliability"]},{"name":"devflow-plan","description":"Unified design planning with gap analysis and design review","commands":["/plan"],"agents":["git","skim","synthesize","design"],"skills":["gap-analysis","design-review","patterns","worktree-support","feature-knowledge","apply-feature-knowledge"],"rules":[]},{"name":"devflow-implement","description":"Complete task implementation workflow - accepts plan documents, issues, or task descriptions","commands":["/implement"],"agents":["git","code","simplify","scrutinize","evaluate","test","validate","knowledge"],"skills":["patterns","qa","quality-gates","worktree-support","feature-knowledge","apply-feature-knowledge"],"rules":[]},{"name":"devflow-code-review","description":"Comprehensive code review with parallel specialized agents","commands":["/code-review"],"agents":["git","review","synthesize"],"skills":["architecture","complexity","consistency","database","dependencies","documentation","performance","regression","reliability","review-methodology","security","testing","worktree-support","apply-feature-knowledge"],"rules":[]},{"name":"devflow-resolve","description":"Process and fix code review issues with blast-radius triage, Code agent fixes, and Validate agent verification","commands":["/resolve"],"agents":["git","triage","code","simplify","validate","knowledge"],"skills":["patterns","security","worktree-support","feature-knowledge","apply-feature-knowledge","apply-decisions"],"rules":[]},{"name":"devflow-debug","description":"Debugging workflows with competing hypothesis investigation via parallel subagents","commands":["/debug"],"agents":["git","synthesize","simplify","knowledge"],"skills":["git","worktree-support","feature-knowledge","apply-feature-knowledge"],"rules":[]},{"name":"devflow-explore","description":"Codebase exploration with structured analysis and optional knowledge base creation","commands":["/explore"],"agents":["skim","synthesize","knowledge"],"skills":["worktree-support","apply-feature-knowledge","feature-knowledge"],"rules":[]},{"name":"devflow-research","description":"Multi-type research with parallel Research agents and trust-aware synthesis","commands":["/research"],"agents":["research","skim","synthesize","knowledge"],"skills":["worktree-support","apply-feature-knowledge","feature-knowledge","research-codebase","research-external","research-market","research-competitor","research-technology"],"rules":[]},{"name":"devflow-release","description":"Adaptive project release with learned configuration","commands":["/release"],"agents":["git","validate"],"skills":["git","worktree-support"],"rules":[]},{"name":"devflow-self-review","description":"Self-review workflow: Simplify agent + Scrutinize agent for code quality","commands":["/self-review"],"agents":["simplify","scrutinize","validate","knowledge"],"skills":["quality-gates","software-design","worktree-support","feature-knowledge","apply-feature-knowledge"],"rules":[]},{"name":"devflow-bug-analysis","description":"Proactive bug finding with static and semantic analysis","commands":["/bug-analysis"],"agents":["git","diagnose","synthesize"],"skills":["apply-decisions","apply-feature-knowledge","complexity","consistency","regression","reliability","security","worktree-support"],"rules":[]},{"name":"devflow-ambient","description":"Orchestrator ambient mode — session charter, per-prompt reminder, plan handoff","commands":[],"agents":["code","validate","simplify","scrutinize","evaluate","test","skim","review","git","synthesize","triage","design","knowledge","research","learning"],"skills":["review-methodology","security","architecture","performance","complexity","consistency","reliability","regression","testing","database","dependencies","documentation","patterns","qa","worktree-support","gap-analysis","design-review","feature-knowledge","apply-feature-knowledge"],"rules":[]},{"name":"devflow-dynamic","description":"Dynamic workflow recipes - dependency-aware tickets→plan→build delivery pipeline","commands":["/dynamic-tickets","/dynamic-plan","/dynamic-build","/dynamic-profile"],"agents":["code","validate","simplify","scrutinize","evaluate","test","review","git","synthesize","knowledge","design"],"skills":["apply-decisions","apply-feature-knowledge","worktree-support","docs-framework"],"optional":true,"rules":[]},{"name":"devflow-typescript","description":"TypeScript language patterns - type safety, generics, utility types, type guards","commands":[],"agents":[],"skills":["typescript"],"optional":true,"rules":["typescript"]},{"name":"devflow-react","description":"React framework patterns - hooks, state management, composition, performance","commands":[],"agents":[],"skills":["react"],"optional":true,"rules":["react"]},{"name":"devflow-accessibility","description":"Web accessibility patterns - WCAG compliance, ARIA roles, keyboard navigation, focus management","commands":[],"agents":[],"skills":["accessibility"],"optional":true,"rules":["accessibility"]},{"name":"devflow-ui-design","description":"UI design patterns - typography, color systems, spacing, motion, responsive design","commands":[],"agents":[],"skills":["ui-design"],"optional":true,"rules":["ui-design"]},{"name":"devflow-go","description":"Go language patterns - error handling, interfaces, concurrency, package design","commands":[],"agents":[],"skills":["go"],"optional":true,"rules":["go"]},{"name":"devflow-java","description":"Java language patterns - records, sealed classes, composition, modern Java features","commands":[],"agents":[],"skills":["java"],"optional":true,"rules":["java"]},{"name":"devflow-python","description":"Python language patterns - type hints, protocols, dataclasses, async programming","commands":[],"agents":[],"skills":["python"],"optional":true,"rules":["python"]},{"name":"devflow-rust","description":"Rust language patterns - ownership, borrowing, error handling, type-driven design","commands":[],"agents":[],"skills":["rust"],"optional":true,"rules":["rust"]}],"featureOwnedSkills":["compliance"],"featureOwnedRules":["compliance"],"assets":[{"path":"src/assets/agents/code.md","kind":"agent","logicalId":"code","owners":["devflow-implement","devflow-resolve","devflow-ambient","devflow-dynamic"],"disposition":"harness-body-and-role-config-generation","sha256":"2a77b725b89fce69e5e19e3294a393ba92401ef81d15a2ff93470d151a64ddef","lines":244,"lexicalReferenceLines":{"claude_paths":[75],"delegation":[108],"skill_calls":[6,7,8,9,10,11,12,13,14,15,41,44,54,60,66,67,68,69,70,71,72,75],"claude_tools":[41,58,60,79,105,107,108,116,120],"claude_models":[4],"workflow":[105],"monitor-protocol":[107,111,115],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"Product code/test writes, commits, optional PR; four fix modes; adapt long-process, skills, compliance, Git and model contracts.","requiredSourceSkills":["software-design","git","patterns","testing","test-driven-development","dependency-research","boundary-validation","worktree-support","apply-feature-knowledge","apply-decisions"]},{"path":"src/assets/agents/design.md","kind":"agent","logicalId":"design","owners":["devflow-plan","devflow-ambient","devflow-dynamic"],"disposition":"harness-body-and-role-config-generation","sha256":"0801d1122dfbb1848801222f33cd34bc43b7f6d798c7ec337b073665b0b25809","lines":113,"lexicalReferenceLines":{"skill_calls":[6,7,8,9,10,24,26,27,31,35,37,38,42],"claude_tools":[26,31,47],"claude_models":[4],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"Gap/design judgment; preserve context, mode and report contract.","requiredSourceSkills":["worktree-support","apply-decisions","gap-analysis","design-review","apply-feature-knowledge"]},{"path":"src/assets/agents/diagnose.md","kind":"agent","logicalId":"diagnose","owners":["devflow-bug-analysis"],"disposition":"harness-body-and-role-config-generation","sha256":"00e51fc0d9ef1749956abe2d9dec387503c0c5c9a6f4c282e0b17c1b9499a718","lines":210,"lexicalReferenceLines":{"skill_calls":[6,7,8,9,10,11,12,13,28,29,33,46],"claude_tools":[28,46,50,90,91,94,131,133],"claude_models":[4],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"No product fixes; writes owned analysis reports.","requiredSourceSkills":["security","reliability","regression","consistency","complexity","worktree-support","apply-decisions","apply-feature-knowledge"]},{"path":"src/assets/agents/evaluate.md","kind":"agent","logicalId":"evaluate","owners":["devflow-implement","devflow-ambient","devflow-dynamic"],"disposition":"harness-body-and-role-config-generation","sha256":"17ad2a3b290c25e2c2b111c6fbe04461b8d4ec65fbcb049f2dc255e77123a4e4","lines":117,"lexicalReferenceLines":{"skill_calls":[6,7,8,23,27],"claude_tools":[31,32],"claude_models":[4],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"Request/plan alignment report; no product fixes.","requiredSourceSkills":["software-design","worktree-support","apply-feature-knowledge"]},{"path":"src/assets/agents/git.md","kind":"agent","logicalId":"git","owners":["devflow-plan","devflow-implement","devflow-code-review","devflow-resolve","devflow-debug","devflow-release","devflow-bug-analysis","devflow-ambient","devflow-dynamic"],"disposition":"harness-body-and-role-config-generation","sha256":"6382d7698d80cdfdfe248ffe96db734a5836fb615ecd7e2634fbb7306b02384f","lines":989,"lexicalReferenceLines":{"skill_calls":[6,7,21,110,112,374,382,392,426,646,759,767,776,860,864,907,941,946],"claude_tools":[121,210,378,403,504,581,671,726,763,787,861,943,951],"claude_models":[4],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"18 operations; authorized Git/remote writes and owned artifacts; operation-specific failure and publication policy.","requiredSourceSkills":["git","worktree-support"]},{"path":"src/assets/agents/knowledge.md","kind":"agent","logicalId":"knowledge","owners":["devflow-implement","devflow-resolve","devflow-debug","devflow-explore","devflow-research","devflow-self-review","devflow-ambient","devflow-dynamic"],"disposition":"harness-body-and-role-config-generation","sha256":"6a6400e8b1ce9cb201fd1665f7d073225368693b2ef450012aba6f2e8bc45161","lines":89,"lexicalReferenceLines":{"skill_calls":[6,7,8,9,33,35],"claude_tools":[11,12,13,14,15,34,38,39,43,46,48,51,52,54,60,89],"claude_models":[4],"literal-agent-config":[4,5,10]},"sourceMetadataKeys":["name","description","model","skills","tools"],"effectContract":"Writes KB/index and commits only owned knowledge paths; never pushes.","requiredSourceSkills":["feature-knowledge","apply-feature-knowledge","apply-decisions","worktree-support"]},{"path":"src/assets/agents/learning.md","kind":"agent","logicalId":"learning","owners":["devflow-core-skills","devflow-ambient"],"disposition":"harness-body-and-role-config-generation","sha256":"9caf37565c804f443853486c839caf23b02a1d8fd13ca74ae0a521de191ed52b","lines":253,"lexicalReferenceLines":{"skill_calls":[13],"claude_tools":[6,7,8,9,10,11,70,79,80,141,187],"claude_models":[4],"headless":[51,57,60,73,80,106,113,174,203,232],"literal-agent-config":[4,5,12]},"sourceMetadataKeys":["name","description","model","tools","skills"],"effectContract":"Claims queues and maintains observations/ledger through helpers; adapt lifetime and models.","requiredSourceSkills":["apply-decisions"]},{"path":"src/assets/agents/research.md","kind":"agent","logicalId":"research","owners":["devflow-research","devflow-ambient"],"disposition":"harness-body-and-role-config-generation","sha256":"17be19eed68ac284e2fbb8e0f8f418d2cbe54373ad89cbff4631bb77f339c65f","lines":134,"lexicalReferenceLines":{"skill_calls":[6,7,8,21,22,23,28,30,31,32,33,34,53,58,61,65,69,128],"claude_tools":[21,65,78,80,82,132],"claude_models":[4],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"Five modes; network where applicable; writes owned reports; skill loading.","requiredSourceSkills":["worktree-support","apply-decisions","apply-feature-knowledge"]},{"path":"src/assets/agents/review.md","kind":"agent","logicalId":"review","owners":["devflow-code-review","devflow-ambient","devflow-dynamic"],"disposition":"harness-body-and-role-config-generation","sha256":"edb5d8855a04c8dafcd02bfcc0d920560df9803f1b9d6ac693ada8cd89c8aa3f","lines":220,"lexicalReferenceLines":{"claude_paths":[220],"claude_names":[103],"skill_calls":[6,7,8,9,14,23,24,34,38,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,63,67,68,117,220],"claude_tools":[23,63,76,77,79,127,129],"claude_models":[4],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"Focus review and owned report writes; project instructions and compliance capability.","requiredSourceSkills":["review-methodology","worktree-support","apply-decisions","apply-feature-knowledge"]},{"path":"src/assets/agents/scrutinize.md","kind":"agent","logicalId":"scrutinize","owners":["devflow-implement","devflow-self-review","devflow-ambient","devflow-dynamic"],"disposition":"harness-body-and-role-config-generation","sha256":"f9a192a7e97357c7afba342de25329d39034c17d9f2e40e267842bd54aa271eb","lines":95,"lexicalReferenceLines":{"skill_calls":[6,7,8,9,10,22,23,25,29],"claude_tools":[22,29,33],"claude_models":[4],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"Quality review, code fixes and commits; preserve fresh-review intent.","requiredSourceSkills":["quality-gates","software-design","worktree-support","apply-decisions","apply-feature-knowledge"]},{"path":"src/assets/agents/simplify.md","kind":"agent","logicalId":"simplify","owners":["devflow-implement","devflow-resolve","devflow-debug","devflow-self-review","devflow-ambient","devflow-dynamic"],"disposition":"harness-body-and-role-config-generation","sha256":"623783f17caad31d47aea7e1524a57c5cec852219c615d0dd2e25584cd33b31c","lines":108,"lexicalReferenceLines":{"claude_names":[28],"skill_calls":[6,7,20],"claude_models":[4],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"Code refinement preserving behavior; target project instructions and commit contract.","requiredSourceSkills":["software-design","worktree-support"]},{"path":"src/assets/agents/skim.md","kind":"agent","logicalId":"skim","owners":["devflow-plan","devflow-explore","devflow-research","devflow-ambient"],"disposition":"harness-body-and-role-config-generation","sha256":"38c4b97c57d771a8a0f5c9c91fc078b10eeb32c74e16d28272df2101223dc291","lines":143,"lexicalReferenceLines":{"skill_calls":[7,19],"claude_tools":[5,12,27,67,69,73,87,133],"claude_models":[4],"workflow":[21],"literal-agent-config":[4,5,6]},"sourceMetadataKeys":["name","description","model","tools","skills"],"effectContract":"Orientation; Skim/rskim and exact file reading.","requiredSourceSkills":["worktree-support"]},{"path":"src/assets/agents/synthesize.md","kind":"agent","logicalId":"synthesize","owners":["devflow-plan","devflow-code-review","devflow-debug","devflow-explore","devflow-research","devflow-bug-analysis","devflow-ambient","devflow-dynamic"],"disposition":"harness-body-and-role-config-generation","sha256":"c27e1268c29dce2f9748f396c8824e642ae800f4ad7afbbc85be230bf1717d8b","lines":402,"lexicalReferenceLines":{"skill_calls":[6,7,8,25,318],"claude_tools":[144,154,156,252,263,265,313,336,338],"claude_models":[4],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"Six synthesis modes; several require owned report writes.","requiredSourceSkills":["review-methodology","docs-framework","worktree-support"]},{"path":"src/assets/agents/test.md","kind":"agent","logicalId":"test","owners":["devflow-implement","devflow-ambient","devflow-dynamic"],"disposition":"harness-body-and-role-config-generation","sha256":"089355924184cebff6e7ed2b856c9c7ba4ed908dafbcc86f68367b98c955d352","lines":155,"lexicalReferenceLines":{"delegation":[78],"skill_calls":[7,8,9,25,33,48],"claude_tools":[5,34,48,59,67,76,78,80,83,85],"claude_models":[4],"workflow":[76],"monitor-protocol":[80],"literal-agent-config":[4,5,6]},"sourceMetadataKeys":["name","description","model","tools","skills"],"effectContract":"Acceptance execution, fixtures/server/browser/process side effects; no product fixes.","requiredSourceSkills":["qa","testing","worktree-support"]},{"path":"src/assets/agents/triage.md","kind":"agent","logicalId":"triage","owners":["devflow-resolve","devflow-ambient"],"disposition":"harness-body-and-role-config-generation","sha256":"8185675bf098f3b1f6d694845d57a419c6a39ad3399be100ca264dca5e55dd54","lines":159,"lexicalReferenceLines":{"skill_calls":[6,7,8,9,21,22,25],"claude_tools":[21,29,30,151,152,156],"claude_models":[4],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"Read and judge only; never writes, builds, tests or commits.","requiredSourceSkills":["security","worktree-support","apply-decisions","apply-feature-knowledge"]},{"path":"src/assets/agents/validate.md","kind":"agent","logicalId":"validate","owners":["devflow-implement","devflow-resolve","devflow-release","devflow-self-review","devflow-ambient","devflow-dynamic"],"disposition":"harness-body-and-role-config-generation","sha256":"aba67bed6f846afb606d243e98be8a69df6ff66c3cdba5d374bf2b32e8601b6e","lines":103,"lexicalReferenceLines":{"delegation":[45],"skill_calls":[6,7,20],"claude_tools":[43,45,47,50,52],"claude_models":[4,60],"workflow":[43],"monitor-protocol":[47],"literal-agent-config":[4,5]},"sourceMetadataKeys":["name","description","model","skills"],"effectContract":"Build/test outputs and caches may be written; never fixes or commits; true exit status.","requiredSourceSkills":["testing","worktree-support"]},{"path":"src/assets/commands/_partials/_compliance.mds","kind":"mds-partial","logicalId":"_compliance","owners":["shared:mds-partial"],"disposition":"shared-contract-adapter","sha256":"3dee7128816481a96a5048cd6811b6ce822042288f1185b71b6fa3a1b3c0de4b","lines":5,"lexicalReferenceLines":{"claude_paths":[2],"skill_calls":[2]},"sourceImports":[]},{"path":"src/assets/commands/_partials/_decisions.mds","kind":"mds-partial","logicalId":"_decisions","owners":["shared:mds-partial"],"disposition":"shared-contract-adapter","sha256":"c12d9d7fc5c7acb04bb632bd12390c5db207155f4357bd48e9dae481bcff9343","lines":20,"lexicalReferenceLines":{"skill_calls":[4,15,17],"claude_tools":[6,17]},"sourceImports":[]},{"path":"src/assets/commands/_partials/_engine.mds","kind":"mds-partial","logicalId":"_engine","owners":["shared:mds-partial"],"disposition":"deferred-runtime","sha256":"26d2d276d122df24d3bc7cf5e984c86d01a1ccf5a85606d08ea750e75dc291e4","lines":244,"lexicalReferenceLines":{"delegation":[149],"skill_calls":[30],"claude_tools":[7,140,148,149,165],"workflow":[118,140],"monitor-protocol":[7,148,154,164,173]},"sourceImports":[]},{"path":"src/assets/commands/_partials/_factory.mds","kind":"mds-partial","logicalId":"_factory","owners":["shared:mds-partial"],"disposition":"deferred-runtime","sha256":"bcef9add9ea6af79b92db7a5a5e75cacfddb4bcb46f33fa9db7afcb3e4b615bb","lines":216,"lexicalReferenceLines":{"claude_tools":[193],"workflow":[16,56,57,99,176,213]},"sourceImports":[]},{"path":"src/assets/commands/_partials/_knowledge.mds","kind":"mds-partial","logicalId":"_knowledge","owners":["shared:mds-partial"],"disposition":"shared-contract-adapter","sha256":"64bac950aa5c3d8f92780a63b7281c17a442868402fdc4af2c7350b3630b8b43","lines":95,"lexicalReferenceLines":{"delegation":[65],"skill_calls":[4,47,75],"claude_tools":[6,18,24,45,51,77,87,89]},"sourceImports":[]},{"path":"src/assets/commands/_partials/_plan_contract.mds","kind":"mds-partial","logicalId":"_plan_contract","owners":["shared:mds-partial"],"disposition":"shared-contract-adapter","sha256":"52bc1410566086e377955d601f81341dda6789dc1d7d265c5cf76d5071be7b38","lines":51,"lexicalReferenceLines":{"skill_calls":[4,39]},"sourceImports":[]},{"path":"src/assets/commands/_partials/_preamble.mds","kind":"mds-partial","logicalId":"_preamble","owners":["shared:mds-partial"],"disposition":"deferred-runtime","sha256":"62138a9caed88779ff9186d729fa6f62097a038ed48b54116544e3efeee8a78f","lines":82,"lexicalReferenceLines":{"claude_names":[2,4,75],"skill_calls":[67],"claude_tools":[67],"claude_models":[43],"workflow":[2,4,6,22,23,26,29,47,49,52,54,57]},"sourceImports":[]},{"path":"src/assets/commands/_partials/_publication.mds","kind":"mds-partial","logicalId":"_publication","owners":["shared:mds-partial"],"disposition":"shared-contract-adapter","sha256":"7d5fcc62e0d6d1fc61eff9e616fbeda75d947dc4f0d7c5859e4704e1c92698c6","lines":7,"lexicalReferenceLines":{"claude_tools":[2]},"sourceImports":[]},{"path":"src/assets/commands/_partials/_roster.mds","kind":"mds-partial","logicalId":"_roster","owners":["shared:mds-partial"],"disposition":"deferred-runtime","sha256":"33392af4651b6be6a4ee349b654cc5173773fc4fb8f0a3fbe36a37a112adc2b0","lines":31,"lexicalReferenceLines":{"claude_tools":[27],"claude_models":[8,9,10,11,12,13,14,15,16,17,18]},"sourceImports":[]},{"path":"src/assets/commands/_partials/_ticket_template.mds","kind":"mds-partial","logicalId":"_ticket_template","owners":["shared:mds-partial"],"disposition":"shared-contract-adapter","sha256":"6f133243c870137d31a627fa27b1edad2bf91549c524e76f7d54628b3040bd74","lines":59,"lexicalReferenceLines":{"skill_calls":[52]},"sourceImports":[]},{"path":"src/assets/commands/_partials/_wave.mds","kind":"mds-partial","logicalId":"_wave","owners":["shared:mds-partial"],"disposition":"deferred-runtime","sha256":"e38b9ca79ac008616cced56e1be6b4fc6e2108a8d9a1379d690bb1b0520f5ea4","lines":123,"lexicalReferenceLines":{"claude_tools":[6],"claude_models":[8,18],"workflow":[67]},"sourceImports":[]},{"path":"src/assets/commands/bug-analysis.mds","kind":"workflow","logicalId":"bug-analysis","owners":["devflow-bug-analysis"],"disposition":"harness-body-and-metadata-generation","sha256":"27579ef21613d096b5209fb9322118482751f49ac471ae0606f14cce496d58ed","lines":353,"lexicalReferenceLines":{"delegation":[33,200,229,335],"skill_calls":[211,212],"claude_tools":[59,153,172,211,213,241,287,307]},"sourceMetadataKeys":["description","output-dir"],"sourceImports":["./_partials/_knowledge.mds","./_partials/_decisions.mds","./_partials/_compliance.mds"]},{"path":"src/assets/commands/code-review.mds","kind":"workflow","logicalId":"code-review","owners":["devflow-code-review"],"disposition":"harness-body-and-metadata-generation","sha256":"e60b68dca9e1e90652f6b7c87203764b02377e7c491e95193dc3d756d15fa76f","lines":355,"lexicalReferenceLines":{"claude_paths":[33],"delegation":[60,220,247,261,350],"skill_calls":[31,33,176,180,193,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,221,222,231,232,333],"claude_tools":[54,92,108,180,231,233,272,277,316]},"sourceMetadataKeys":["description","output-dir"],"sourceImports":["./_partials/_knowledge.mds","./_partials/_decisions.mds","./_partials/_compliance.mds","./_partials/_publication.mds"]},{"path":"src/assets/commands/debug.mds","kind":"workflow","logicalId":"debug","owners":["devflow-debug"],"disposition":"harness-body-and-metadata-generation","sha256":"f1a152cc12e10b31101ad937cb2e6906797a68955de3ade0f3328a6ae904996c","lines":224,"lexicalReferenceLines":{"delegation":[49,68,87,95,113,125,175],"skill_calls":[33,37,175],"questions":[173,203],"claude_tools":[37,75,205],"workflow":[22,46]},"sourceMetadataKeys":["description","output-dir"],"sourceImports":["./_partials/_knowledge.mds","./_partials/_decisions.mds"]},{"path":"src/assets/commands/dynamic-build.mds","kind":"workflow","logicalId":"dynamic-build","owners":["devflow-dynamic"],"disposition":"deferred-runtime","sha256":"053cbbe2ea988777302bf19381a8fdd00c2d4217be24a64fed61dba0330d2745","lines":534,"lexicalReferenceLines":{"claude_names":[19,36],"delegation":[515],"skill_calls":[27,56,74,87,132,512,522,526],"questions":[525],"claude_tools":[56,58,137,149,200,209,217,329,369,414,512],"claude_models":[466],"workflow":[19,36,60,184,244,278,298,337],"monitor-protocol":[137,149,200,209,217,329,369,379,391]},"sourceMetadataKeys":["description","argument-hint","output-dir"],"sourceImports":["./_partials/_preamble.mds","./_partials/_compliance.mds","./_partials/_roster.mds","./_partials/_engine.mds","./_partials/_wave.mds","./_partials/_plan_contract.mds"]},{"path":"src/assets/commands/dynamic-plan.mds","kind":"workflow","logicalId":"dynamic-plan","owners":["devflow-dynamic"],"disposition":"deferred-runtime","sha256":"5879de1c692d484f79848e4bdd5f9bd08d157891e73824655e508e0cbb0b9550","lines":244,"lexicalReferenceLines":{"claude_names":[16,33],"skill_calls":[16,44,53,58,73,112,209,238,244],"questions":[66,68,72,75,90,238],"claude_tools":[44,46,62,71,99,101,110,114,163,179,181],"workflow":[16,33,109,122]},"sourceMetadataKeys":["description","argument-hint","output-dir"],"sourceImports":["./_partials/_preamble.mds","./_partials/_roster.mds","./_partials/_plan_contract.mds"]},{"path":"src/assets/commands/dynamic-profile.mds","kind":"workflow","logicalId":"dynamic-profile","owners":["devflow-dynamic"],"disposition":"scope-decision","sha256":"a1a9b51bec2b42733e4348432b769ec7e6339c7be7ab5dec95eae4d1b3296378","lines":132,"lexicalReferenceLines":{"claude_paths":[22,29,41,42,62,67,68,69],"skill_calls":[16,109,124,125],"questions":[14,39,62,63,64,67],"claude_tools":[41,42,67,68,69,81],"workflow":[18,96,99],"headless":[29,67]},"sourceMetadataKeys":["description","argument-hint","output-dir"],"sourceImports":["./_partials/_preamble.mds"]},{"path":"src/assets/commands/dynamic-tickets.mds","kind":"workflow","logicalId":"dynamic-tickets","owners":["devflow-dynamic"],"disposition":"deferred-runtime","sha256":"1bf015d2ea04ae62920f4975fd0ee737c061ad2329f86c4329b9b18db1741b53","lines":226,"lexicalReferenceLines":{"claude_names":[17,34],"skill_calls":[47,95,216,220],"claude_tools":[47,49,51,60,96,148,154],"workflow":[17,34,91,103,104,122,144]},"sourceMetadataKeys":["description","argument-hint","output-dir"],"sourceImports":["./_partials/_preamble.mds","./_partials/_roster.mds","./_partials/_ticket_template.mds","./_partials/_factory.mds"]},{"path":"src/assets/commands/explore.mds","kind":"workflow","logicalId":"explore","owners":["devflow-explore"],"disposition":"harness-body-and-metadata-generation","sha256":"b4bc5dbaccd6cc453ca96e6aa608285137d05bee438f907c3fa670d9e27767dd","lines":150,"lexicalReferenceLines":{"delegation":[43,54,67],"skill_calls":[35],"questions":[83,91],"claude_tools":[35],"workflow":[22]},"sourceMetadataKeys":["description","output-dir"],"sourceImports":["./_partials/_knowledge.mds","./_partials/_decisions.mds"]},{"path":"src/assets/commands/implement.mds","kind":"workflow","logicalId":"implement","owners":["devflow-implement"],"disposition":"harness-body-and-metadata-generation","sha256":"921d2f0ffe986a7914007aff44ce7858834991255ec416d3e21711ae9b1c1a29","lines":496,"lexicalReferenceLines":{"delegation":[59,116,138,156,183,196,224,236,258,273,291,309,326,337,353,369,380,396,400],"skill_calls":[50,409],"claude_tools":[78,174,475],"claude_models":[224,291,337,380],"workflow":[24,62,63,65,77]},"sourceMetadataKeys":["description","output-dir"],"sourceImports":["./_partials/_knowledge.mds","./_partials/_decisions.mds","./_partials/_compliance.mds"]},{"path":"src/assets/commands/plan.mds","kind":"workflow","logicalId":"plan","owners":["devflow-plan"],"disposition":"harness-body-and-metadata-generation","sha256":"8cffdafc1fd231ce022127f8bb5c16181c3fd8f5f9793084363f3e9f7cbf19eb","lines":545,"lexicalReferenceLines":{"delegation":[69,78,107,147,191,212,274,304,323,438],"skill_calls":[102,119,130,200],"questions":[87,228,337,433,473,499,520],"claude_tools":[119,371,476],"workflow":[26,32,66]},"sourceMetadataKeys":["description","output-dir"],"sourceImports":["./_partials/_knowledge.mds","./_partials/_decisions.mds","./_partials/_compliance.mds"]},{"path":"src/assets/commands/release.md","kind":"workflow","logicalId":"release","owners":["devflow-release"],"disposition":"harness-body-and-metadata-generation","sha256":"1eefa92b7027205bd5b46eb3a5e9cda93af1465c01233ce906d9a77ee20c0bc3","lines":206,"lexicalReferenceLines":{"claude_paths":[61],"delegation":[107,133,135,136],"skill_calls":[37,61],"questions":[87,100,120],"claude_tools":[43,51,70,109,167,176,180],"workflow":[20,26]},"sourceMetadataKeys":["description"],"sourceImports":[]},{"path":"src/assets/commands/research.mds","kind":"workflow","logicalId":"research","owners":["devflow-research"],"disposition":"harness-body-and-metadata-generation","sha256":"9190b6651aaa7d93c612dc11e8f5f8b60228b0227780bb79a1a0d7c705949f32","lines":164,"lexicalReferenceLines":{"delegation":[61,70,86,112],"skill_calls":[36,112],"questions":[100,111],"claude_tools":[36,51,161],"workflow":[23]},"sourceMetadataKeys":["description","output-dir"],"sourceImports":["./_partials/_knowledge.mds","./_partials/_decisions.mds"]},{"path":"src/assets/commands/resolve.mds","kind":"workflow","logicalId":"resolve","owners":["devflow-resolve"],"disposition":"harness-body-and-metadata-generation","sha256":"56aa3f325ff54b66548ed3a29c5a50399695f95b99f662fdc8527d0e459712bd","lines":651,"lexicalReferenceLines":{"claude_paths":[33],"delegation":[48,148,165,216,258,275,289,325,329,343,374,392,415],"skill_calls":[31,33,173,174],"claude_tools":[115,173,237,242,501,533],"claude_models":[275,492,505]},"sourceMetadataKeys":["description","output-dir"],"sourceImports":["./_partials/_knowledge.mds","./_partials/_decisions.mds","./_partials/_compliance.mds","./_partials/_publication.mds"]},{"path":"src/assets/commands/self-review.mds","kind":"workflow","logicalId":"self-review","owners":["devflow-self-review"],"disposition":"harness-body-and-metadata-generation","sha256":"2243b619a83d24e65dc7921951d9dce6c96d024aef7220798f8269f2dbae0e44","lines":156,"lexicalReferenceLines":{"delegation":[46,60,78],"skill_calls":[31,66,67],"claude_tools":[31,66,126]},"sourceMetadataKeys":["description","output-dir"],"sourceImports":["./_partials/_knowledge.mds","./_partials/_decisions.mds"]},{"path":"src/assets/rules/accessibility.md","kind":"rule","logicalId":"accessibility","owners":["devflow-accessibility"],"disposition":"shared-rule-instruction-composition","sha256":"cb85b1f9dd59a6af213031d88dbc5bda5e5a6b60e8379cf4009f9f64a3714033","lines":11,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/compliance.md","kind":"rule","logicalId":"compliance","owners":["feature:compliance"],"disposition":"shared-rule-instruction-composition","sha256":"5c7174bdffeedd1865c913f582d7cff9087b7a4b4e317904352c45fe170c7ffe","lines":15,"lexicalReferenceLines":{"composition-token":[14,15]},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/engineering.md","kind":"rule","logicalId":"engineering","owners":["devflow-core-skills"],"disposition":"shared-rule-instruction-composition","sha256":"9fe78da7cb64aecb5d3a5705e6f72bfa807b495aa4c6cbb9ab949c77bff5dc63","lines":13,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/go.md","kind":"rule","logicalId":"go","owners":["devflow-go"],"disposition":"shared-rule-instruction-composition","sha256":"4459662a629b28efc633ead270d307c324ad81b168fbbcf9220a5e3f7faaa96f","lines":12,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/java.md","kind":"rule","logicalId":"java","owners":["devflow-java"],"disposition":"shared-rule-instruction-composition","sha256":"f0d877ac5d3cd9481410c1e0751ed94dd6b5f79c43d1b954b02b1703f852920b","lines":12,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/python.md","kind":"rule","logicalId":"python","owners":["devflow-python"],"disposition":"shared-rule-instruction-composition","sha256":"53855eb1c55cdf75665fb74adfed06d4f3a0f859b67fccbfc3761caaa37a33b0","lines":12,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/quality.md","kind":"rule","logicalId":"quality","owners":["devflow-core-skills"],"disposition":"shared-rule-instruction-composition","sha256":"028ee3adf8efef6e9e2070e7c6fa5d46c35db55e76ffc5e526d00f722d6c2612","lines":14,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/react.md","kind":"rule","logicalId":"react","owners":["devflow-react"],"disposition":"shared-rule-instruction-composition","sha256":"9c0178e45aa1abeb17dffd25aaae73d64cf0202ed3cb228d2e76c05e7433b64c","lines":11,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/reliability.md","kind":"rule","logicalId":"reliability","owners":["devflow-core-skills"],"disposition":"shared-rule-instruction-composition","sha256":"268cacad0000774cac493ea8f0e6cbbaaf018036891a24521453d527d9e9988c","lines":12,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/rust.md","kind":"rule","logicalId":"rust","owners":["devflow-rust"],"disposition":"shared-rule-instruction-composition","sha256":"06a3e5af0b3835905bf090206139005b960b9da65644825073d0d31a0965432e","lines":12,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/security.md","kind":"rule","logicalId":"security","owners":["devflow-core-skills"],"disposition":"shared-rule-instruction-composition","sha256":"e1afe13dad73615d1f94f4eba6f6a0c0f082cf774b7b8d89fe8874213af365f9","lines":12,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/typescript.md","kind":"rule","logicalId":"typescript","owners":["devflow-typescript"],"disposition":"shared-rule-instruction-composition","sha256":"0de9777427a2f96e1f9f0cdd67525a7ae9c8b535456eca407293f63ae9d5159e","lines":12,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/rules/ui-design.md","kind":"rule","logicalId":"ui-design","owners":["devflow-ui-design"],"disposition":"shared-rule-instruction-composition","sha256":"8a2757e2d40f153c115140b5d718f5f3e06cad6f1f038f193e0c10bef04bd77e","lines":11,"lexicalReferenceLines":{},"sourceMetadataKeys":["paths"]},{"path":"src/assets/scripts/hooks/assets/orchestrator-charter.md","kind":"script-or-hook","logicalId":"orchestrator-charter","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"c15a85bf52ec4b7af88acb78d0ded8b832c34d49f3edfcfbc46e712ae5b4ebc5","lines":22,"lexicalReferenceLines":{"claude_names":[3],"skill_calls":[13,22],"questions":[2,22],"claude_tools":[15],"claude_models":[1,10,11,12,21]}},{"path":"src/assets/scripts/hooks/background-memory-update","kind":"script-or-hook","logicalId":"background-memory-update","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"41f95af9f4880691b59f2af2616f34a53f879a925717cc6639a197931397bf6d","lines":603,"lexicalReferenceLines":{"questions":[290],"claude_tools":[404,406,409,436,493],"claude_models":[5,451,491],"headless":[5,25,66,103,451,481,524,532,548]}},{"path":"src/assets/scripts/hooks/capture-prompt","kind":"script-or-hook","logicalId":"capture-prompt","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"e3c82dff952dacb24ecb48b6bdc7173d01c6197132b7654ee460822545486e09","lines":87,"lexicalReferenceLines":{"headless":[15,81]}},{"path":"src/assets/scripts/hooks/capture-question","kind":"script-or-hook","logicalId":"capture-question","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"955d9367aeb5a0b9d7068adf91fd1dd5932bb17ebf32ffc57ec3f99d1bafb15b","lines":153,"lexicalReferenceLines":{"claude_paths":[22],"questions":[3,29,50,51],"headless":[12,143]}},{"path":"src/assets/scripts/hooks/capture-turn","kind":"script-or-hook","logicalId":"capture-turn","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"060bc8511b157fe8a36af2a9157b6f3a2f8af4bedb3c5d87d5c4fc5df21724bc","lines":105,"lexicalReferenceLines":{"claude_tools":[71],"headless":[99]}},{"path":"src/assets/scripts/hooks/debug-trace","kind":"script-or-hook","logicalId":"debug-trace","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"1a69fa9dc45d9b29fdffb49c3781cafdc781e597e79d6d991bea7d05859b1364","lines":75,"lexicalReferenceLines":{"claude_paths":[14]}},{"path":"src/assets/scripts/hooks/decisions-usage-scan.cjs","kind":"script-or-hook","logicalId":"decisions-usage-scan","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"529047df0d679a6d6050db7ec32829eb59b18c3fc748db135b83615e1a5aff69","lines":131,"lexicalReferenceLines":{"claude_tools":[30,50]}},{"path":"src/assets/scripts/hooks/ensure-devflow-init","kind":"script-or-hook","logicalId":"ensure-devflow-init","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"2737735ee262f340a5d0948b4d8c91385cd9abc56ccb5c068bf752af09ad7431","lines":39,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/ensure-proxy","kind":"script-or-hook","logicalId":"ensure-proxy","owners":["shared:script-or-hook"],"disposition":"claude-specific","sha256":"31462d0c6d17fc2a427da5034e370a0f9fdfcd6c42069d9839416e59f0b2fe43","lines":353,"lexicalReferenceLines":{"claude_tools":[132,178,210,303],"headless":[25]}},{"path":"src/assets/scripts/hooks/ensure-root-gitignore","kind":"script-or-hook","logicalId":"ensure-root-gitignore","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"b301f5065bcde764fda3e0824419832da52f247dd523ca4c9c7f57ddb8eb4455","lines":125,"lexicalReferenceLines":{"claude_paths":[100]}},{"path":"src/assets/scripts/hooks/get-mtime","kind":"script-or-hook","logicalId":"get-mtime","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"c1b65d6034e3ee22efb22262f06423b3d67ab7147f49604940c466a0e739bd48","lines":23,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/git-marker","kind":"script-or-hook","logicalId":"git-marker","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"acd434ab6d8d31a64bfa260e0b9d4ca247fd3c647db917543d6037d4d8a17be5","lines":16,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/hook-bootstrap","kind":"script-or-hook","logicalId":"hook-bootstrap","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"e33ff94ce019424db50b7fb78d9015c62a5ee65ab0be80f8ee279249fa5ffa66","lines":25,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/hook-log-init","kind":"script-or-hook","logicalId":"hook-log-init","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"af52fa336010b82341c1260f4e45a578b7237d47a13f8bda4c970d28cf6e030f","lines":41,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/is-hex-sha","kind":"script-or-hook","logicalId":"is-hex-sha","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"a777f29e59b1acd3426e9e485892701c801e5ea0a481858d3b7dc6b258b9cd23","lines":14,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/json-helper.cjs","kind":"script-or-hook","logicalId":"json-helper","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"eda51f278c164a12555979395219e7b38d5a58509c54cf425635858bfa11c166","lines":910,"lexicalReferenceLines":{"claude_names":[18],"claude_tools":[10,11,20,21,97,160,175,270,399,464,562,568,710,716,744,842],"headless":[205,206,538,738]}},{"path":"src/assets/scripts/hooks/json-parse","kind":"script-or-hook","logicalId":"json-parse","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"4d7e3c8983d7b56b5d1d4d16818f67c89a685ce392fea3a9bfaf387ecafa46a4","lines":243,"lexicalReferenceLines":{"claude_names":[190],"headless":[129]}},{"path":"src/assets/scripts/hooks/learning-lock","kind":"script-or-hook","logicalId":"learning-lock","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"8d1c308650e2f3343f750586462ceb24207b124c777221e92ec908419374fa6f","lines":44,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/lib/decisions-format.cjs","kind":"script-or-hook","logicalId":"decisions-format","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"545ac305651d743b7255a365bd77d49eaf76f7c6cd462fafb4bcb5351ba438df","lines":522,"lexicalReferenceLines":{"skill_calls":[58],"claude_tools":[505],"headless":[302,324]}},{"path":"src/assets/scripts/hooks/lib/mkdir-lock.cjs","kind":"script-or-hook","logicalId":"mkdir-lock","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"3c1c1a73dcba8f18e68f0ce1d753a8640929a55fccec4c4c1ee70ff98f3ac51a","lines":106,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/lib/project-paths.cjs","kind":"script-or-hook","logicalId":"project-paths","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"4e808671ca7ebd2dd6cc0cf26d850ade25a674c1d717b17b13285a2e06498907","lines":230,"lexicalReferenceLines":{"headless":[55,57,84,86,89,91,94,96,138,140]}},{"path":"src/assets/scripts/hooks/lib/render-decisions.cjs","kind":"script-or-hook","logicalId":"render-decisions","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"1fd64c97b3cf918e8c4054df1d29f309bbf272248c315520afa8935e637b3abe","lines":429,"lexicalReferenceLines":{"claude_tools":[233,287,295,321,358],"headless":[4,18,54]}},{"path":"src/assets/scripts/hooks/lib/safe-path.cjs","kind":"script-or-hook","logicalId":"safe-path","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"0df7a3e08eb60372f66c63141601eca2d5eeb5a9a181fbd3bbb6107eb3d01a80","lines":29,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/log-paths","kind":"script-or-hook","logicalId":"log-paths","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"a1083afb3458a32f42ee6415014f05fcfbff4dd0cd3622f223c503c1ab6619b1","lines":24,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/memory-worker","kind":"script-or-hook","logicalId":"memory-worker","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"c1ce44cffeda904fccd9204b63195997df60fe1d7e65326170b7d9dcc7e6f1bf","lines":101,"lexicalReferenceLines":{"claude_tools":[38]}},{"path":"src/assets/scripts/hooks/pre-compact-memory","kind":"script-or-hook","logicalId":"pre-compact-memory","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"ffd101730604ca5d78519b00aba89651ff45302a3cc1233bb4bcc2af721389fe","lines":144,"lexicalReferenceLines":{"claude_tools":[91],"headless":[16]}},{"path":"src/assets/scripts/hooks/preamble","kind":"script-or-hook","logicalId":"preamble","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"236bcb99331346e20606f3e624aa102d956a32089b911e25db76c91ddd382aab","lines":77,"lexicalReferenceLines":{"claude_names":[5,8,53],"skill_calls":[6,64,65],"questions":[5,63,65],"claude_models":[69,73],"headless":[18]}},{"path":"src/assets/scripts/hooks/queue-append","kind":"script-or-hook","logicalId":"queue-append","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"29fa1bf519ffec291a86153ddd68e2b01ceda013889ed9c66478609f04082d93","lines":120,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/resolve-project-root","kind":"script-or-hook","logicalId":"resolve-project-root","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"3b24c391eab8ddcc0d28d6c4927e974d1b8d7a67627e3c4b0ec65e7f0c00728c","lines":37,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/run-hook","kind":"script-or-hook","logicalId":"run-hook","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"a01de4e8b91cd9c72f3ea6c5839ebae298900da3ef10f463e1f659c6e75b8f9a","lines":31,"lexicalReferenceLines":{}},{"path":"src/assets/scripts/hooks/session-start-context","kind":"script-or-hook","logicalId":"session-start-context","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"8704b44f85f92ca96da003b17406573a1aa783701398f42b33dd41c41814ff73","lines":180,"lexicalReferenceLines":{"claude_names":[179],"delegation":[155],"claude_models":[134,142,148,149],"headless":[27,115]}},{"path":"src/assets/scripts/hooks/session-start-memory","kind":"script-or-hook","logicalId":"session-start-memory","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"8d9cc712eaaf12e38897c305f5e8a5896668cded596fcadbfecff8580acd5554","lines":317,"lexicalReferenceLines":{"claude_names":[316],"headless":[16,68,73,83,85,86,136,145,153]}},{"path":"src/assets/scripts/hooks/session-start-orchestrator","kind":"script-or-hook","logicalId":"session-start-orchestrator","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"69b8094fe850c63b95da374f440aa284ef89b7c26e6b4291e4de11c3cccd7066","lines":54,"lexicalReferenceLines":{"claude_names":[9],"questions":[8],"headless":[17]}},{"path":"src/assets/scripts/hud.sh","kind":"script-or-hook","logicalId":"hud","owners":["shared:script-or-hook"],"disposition":"harness-or-process-adapter","sha256":"27dd60365d9de8320e33bce47b08d038eaf089d49ab349c0b11afaefdd1c3062","lines":5,"lexicalReferenceLines":{"claude_names":[3]}},{"path":"src/assets/scripts/redact-secrets.cjs","kind":"script-or-hook","logicalId":"redact-secrets","owners":["shared:script-or-hook"],"disposition":"shared-mechanics-with-contract-validation","sha256":"91c60ec08d0052d8851c0d63a25b111435f1fea53cd83aced62aaebaf2c2c101","lines":410,"lexicalReferenceLines":{}},{"path":"src/assets/skills/accessibility/SKILL.md","kind":"skill","logicalId":"accessibility","owners":["devflow-accessibility"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"ca3cf2702ccffa383b226690006cf182f9c4faaa80f9ef773cab9f063b87c28f","lines":145,"lexicalReferenceLines":{"claude_tools":[5],"legacy-skill-metadata":[4,5,6]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools","activation"],"sourceActivationDeclared":true},{"path":"src/assets/skills/accessibility/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-accessibility"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"c2834c83dfaf039d23fe138c90ec799ef6ec05453031426bbbce0a5ffc3cd7f3","lines":171,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/accessibility/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-accessibility"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"8457412cb4579d53f1bbc06faa7c4cf06d79b00316da8898dda9df528691cfd2","lines":398,"lexicalReferenceLines":{"claude_tools":[321]}},{"path":"src/assets/skills/accessibility/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-accessibility"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"b43032c8a86945ac93a5c328636b695f48964195279a1ad609a9146a7708b2fb","lines":26,"lexicalReferenceLines":{}},{"path":"src/assets/skills/accessibility/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-accessibility"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"138578478cc7a3faa6cbc30136adce5f3e0dc5e236dd1aaba0ba07b9749cace8","lines":358,"lexicalReferenceLines":{"claude_tools":[316,320]}},{"path":"src/assets/skills/apply-decisions/SKILL.md","kind":"skill","logicalId":"apply-decisions","owners":["devflow-core-skills","devflow-resolve","devflow-bug-analysis","devflow-dynamic"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"811ee73ed45049cbe01548a7bafd812bdee34547af7e0dcc1315548c7f9e40d2","lines":100,"lexicalReferenceLines":{"claude_tools":[3,5,17,26,39,51,53,81],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/apply-feature-knowledge/SKILL.md","kind":"skill","logicalId":"apply-feature-knowledge","owners":["devflow-core-skills","devflow-plan","devflow-implement","devflow-code-review","devflow-resolve","devflow-debug","devflow-explore","devflow-research","devflow-self-review","devflow-bug-analysis","devflow-ambient","devflow-dynamic"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"584e83392c194302f4d95968bff3ec231463b08f495cb34161b02a3e3ab88ebc","lines":69,"lexicalReferenceLines":{"claude_tools":[5,16,22,26,42,58],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false}]}}

[dean0x]

Evidence inventory, part 2/4. The current issue body owns the specification and decisions.

Machine-readable source roster and evidence — part 2/4

To reconstruct the complete inventory, read parts in order, merge fields into one object, and concatenate each named array from arrays. Source hashes refer to the recorded Devflow baseline. Historical 0.2.0 probes and the new 0.4.2 upgrade probes are distinguished.

{"snapshot":"devflow-codex-compatibility-2026-09-08","part":2,"parts":4,"fields":{},"arrays":{"assets":[{"path":"src/assets/skills/architecture/SKILL.md","kind":"skill","logicalId":"architecture","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"531f51179aad8d38bac73817b9c0fce62a567cbddd0e85622df2703e2d110a42","lines":138,"lexicalReferenceLines":{"claude_tools":[5,36,125,138],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/architecture/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"1cbdf758b54e4790f55345294aa2b3d94f43d6ce3be69b18bcf37d5621d68b1e","lines":337,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/architecture/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"3e026c15bff511afc7cd89aa1cc6cb6bd6ce0c2c2fadb375eacee3784f4b5825","lines":378,"lexicalReferenceLines":{"claude_tools":[96]}},{"path":"src/assets/skills/architecture/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"d6fd946950426bc2160cf7a4d53a23f71e0cc7ceed3df83758ae3acc6cdcc0a4","lines":41,"lexicalReferenceLines":{"claude_tools":[9]}},{"path":"src/assets/skills/architecture/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"edd8e897d115efcb1db7196f679b06a0cf365de25017dd1ead8a6b59b51f9589","lines":314,"lexicalReferenceLines":{"claude_tools":[53,65]}},{"path":"src/assets/skills/boundary-validation/SKILL.md","kind":"skill","logicalId":"boundary-validation","owners":["devflow-core-skills"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"27766d6aaafdb2b35eb1e4f633932b3effc37662c5f565141f88a7664f0ed0de","lines":119,"lexicalReferenceLines":{"skill_calls":[8,20],"questions":[5],"claude_tools":[5,107],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/boundary-validation/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-core-skills"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"9721d982cc6106e7e3cbb22697e79168184208a724aadfbfaadecbf35f23b733","lines":283,"lexicalReferenceLines":{"skill_calls":[281,282,283],"claude_tools":[3]}},{"path":"src/assets/skills/boundary-validation/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-core-skills"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"8731cc5c047cb70ce70fba5480d9926d44e965897ee37b385fec7ae6b4f74a6f","lines":283,"lexicalReferenceLines":{}},{"path":"src/assets/skills/boundary-validation/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-core-skills"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"fd0d822aa7b069050fe75cc86aa78b7d7b84a8a94abef4eb8cc2a0515d1509e7","lines":41,"lexicalReferenceLines":{}},{"path":"src/assets/skills/boundary-validation/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-core-skills"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"81f3571e3dbb8cffe954daf906bce06e454de2bb236858c8e2da8a870335f677","lines":211,"lexicalReferenceLines":{}},{"path":"src/assets/skills/complexity/SKILL.md","kind":"skill","logicalId":"complexity","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"40104ddde76b1c5f2ac1e7f18f1119099ee0dbc8c642ae4b8e820fd11a30c675","lines":150,"lexicalReferenceLines":{"skill_calls":[10,114],"claude_tools":[5,128],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/complexity/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"d3366c91520c75bc02ff276416a4886fd03c5f54d368c578dc969e85eadd0fe5","lines":264,"lexicalReferenceLines":{}},{"path":"src/assets/skills/complexity/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"5f3c2f5ea3be60593396629c722d613e661a08821a34c18f961cc8e2748f3a80","lines":487,"lexicalReferenceLines":{}},{"path":"src/assets/skills/complexity/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"92dc194b8b068ad2fc59f19c66e4db3baf2edd28a0db72c173dadaf371347bc3","lines":361,"lexicalReferenceLines":{}},{"path":"src/assets/skills/compliance/SKILL.md","kind":"skill","logicalId":"compliance","owners":["feature:compliance"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"a43989b8cc64407c712fab83526af33469eec8679c1d574c7ea342cfbf7a3f76","lines":121,"lexicalReferenceLines":{"skill_calls":[14],"claude_tools":[5,119],"legacy-skill-metadata":[4,5],"composition-token":[14,25,102,113,121]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/compliance/frameworks/gdpr/fragment.md","kind":"compliance-framework-asset","logicalId":"fragment","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"482109911b6015bf656a3cd98ac3d4829d232565a48736a2adfefa6b05318ade","lines":11,"lexicalReferenceLines":{}},{"path":"src/assets/skills/compliance/frameworks/gdpr/reference.md","kind":"compliance-framework-asset","logicalId":"reference","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"45a0b099ebb78aaa97e5f538f7b4c86c31886629c4ecaad54fd0581492f74281","lines":50,"lexicalReferenceLines":{}},{"path":"src/assets/skills/compliance/frameworks/hipaa/fragment.md","kind":"compliance-framework-asset","logicalId":"fragment","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"7933cde4cb2985b6ac3156e626bdf89f4860d2629597a49af430ebc491296ba7","lines":11,"lexicalReferenceLines":{}},{"path":"src/assets/skills/compliance/frameworks/hipaa/reference.md","kind":"compliance-framework-asset","logicalId":"reference","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"1d224346596c171ee82b1997d8b03a7cfd56e845f61e803cf10bbb77cda9e4ec","lines":44,"lexicalReferenceLines":{}},{"path":"src/assets/skills/compliance/frameworks/iso-27001/fragment.md","kind":"compliance-framework-asset","logicalId":"fragment","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"ba2e69a3c449368b35ab5f32c1d9fa18b94d038102aa4847f768a488b16af02c","lines":10,"lexicalReferenceLines":{}},{"path":"src/assets/skills/compliance/frameworks/iso-27001/reference.md","kind":"compliance-framework-asset","logicalId":"reference","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"cd8fb81fba8ec5f7fcd6d09f190fc1615f61a9374aa016c8b8f3ac6f16918132","lines":45,"lexicalReferenceLines":{"monitor-protocol":[20]}},{"path":"src/assets/skills/compliance/frameworks/pci-dss/fragment.md","kind":"compliance-framework-asset","logicalId":"fragment","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"92762aeb19452191496a0570038fdd6eca4c92a0cfae3f9ec04f357229c294b5","lines":11,"lexicalReferenceLines":{}},{"path":"src/assets/skills/compliance/frameworks/pci-dss/reference.md","kind":"compliance-framework-asset","logicalId":"reference","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"6b8bdd2052ec8e17906bc1023159dcf4c2437242093db5737a198b115ecd5601","lines":55,"lexicalReferenceLines":{"monitor-protocol":[36]}},{"path":"src/assets/skills/compliance/frameworks/soc2/fragment.md","kind":"compliance-framework-asset","logicalId":"fragment","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"02538ca60ba9b03da981e8562a788474594791c15dcb55fbeab7c506201813aa","lines":10,"lexicalReferenceLines":{}},{"path":"src/assets/skills/compliance/frameworks/soc2/reference.md","kind":"compliance-framework-asset","logicalId":"reference","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"ff6b7afcd653425ed1637b8165cad0f079f3facdcbf5c830bf400140bf18d47e","lines":53,"lexicalReferenceLines":{}},{"path":"src/assets/skills/compliance/frameworks/sox/fragment.md","kind":"compliance-framework-asset","logicalId":"fragment","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"d2c4e7cb51f6e673a856a30b93c86f5e0c75788810028ed192ad66a1aeb82d6f","lines":10,"lexicalReferenceLines":{}},{"path":"src/assets/skills/compliance/frameworks/sox/reference.md","kind":"compliance-framework-asset","logicalId":"reference","owners":["feature:compliance"],"disposition":"shared-feature-owned-composition","sha256":"770e79ced7d0d7ad3cee30efb7c5b5cd07df00922078f3a6c9365c8c4514ec83","lines":67,"lexicalReferenceLines":{}},{"path":"src/assets/skills/compliance/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["feature:compliance"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"910b238d7b4eb823b76bd4036327f9809fa21960fbbea7edc393f10aa1809a86","lines":108,"lexicalReferenceLines":{"claude_tools":[3,8]}},{"path":"src/assets/skills/compliance/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["feature:compliance"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"39a478b483e45e532bbc0228dbdd1ff5feffdbeb5462bf1922d56df6fbd29dec","lines":28,"lexicalReferenceLines":{}},{"path":"src/assets/skills/consistency/SKILL.md","kind":"skill","logicalId":"consistency","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"ec7c751f3423d52b71685fc0f9bfb802494ed5d92b882d60aa1347ab7373d626","lines":140,"lexicalReferenceLines":{"skill_calls":[10],"claude_tools":[5,114],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/consistency/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"72c8e9eb52350bff18e6342b1cd4c25fc3b3c17e54cba834a7f925b6d2841cd2","lines":207,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/consistency/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"d903ce48a3b9a954bbd7eb0af7ce08017d143e566bd19b0a60709d7bb641be36","lines":202,"lexicalReferenceLines":{}},{"path":"src/assets/skills/consistency/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"1a190d0e9418d78e28f80efbb43a6efa0520429ca0f60ce11454e86aab78abd3","lines":213,"lexicalReferenceLines":{}},{"path":"src/assets/skills/database/SKILL.md","kind":"skill","logicalId":"database","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"f87d12d7aa63600c261fd870af59d41f7aa549734d01d4bb2217f88e8f334a87","lines":134,"lexicalReferenceLines":{"skill_calls":[10],"claude_tools":[5],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/database/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"49d95c21e7d2d916a5c01e13cf3394297840a610d16f60faebdcecc75d59c38c","lines":208,"lexicalReferenceLines":{"claude_tools":[206]}},{"path":"src/assets/skills/database/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"f015be3b6f004e2bb15a948907240ef6c31313046fcb87af26b0b92f1a9817ae","lines":394,"lexicalReferenceLines":{}},{"path":"src/assets/skills/database/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"5551776b2397a42aead170092bd5becf36a52496da44b1b53852b9b4d722bb6e","lines":332,"lexicalReferenceLines":{"claude_tools":[52,319]}},{"path":"src/assets/skills/dependencies/SKILL.md","kind":"skill","logicalId":"dependencies","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"de8abf5432fa531412f11d5f632ca66c0a8afe108e6d22ba6e34e17e03f3fa77","lines":141,"lexicalReferenceLines":{"skill_calls":[10],"claude_tools":[5],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/dependencies/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"3c3cc487aed73739a80072c7f732043c7b23547667ce6160baaa7bdd85f2ea3e","lines":181,"lexicalReferenceLines":{}},{"path":"src/assets/skills/dependencies/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"59e4efabd0ee8da16c0308c17e4be6a9984420fbb0dbd262e293c020d97622cb","lines":225,"lexicalReferenceLines":{"workflow":[90]}},{"path":"src/assets/skills/dependencies/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"3b37e1303d853a0130420d406cc72d3394d93457c74d484e340740a801eb8941","lines":247,"lexicalReferenceLines":{}},{"path":"src/assets/skills/dependency-research/SKILL.md","kind":"skill","logicalId":"dependency-research","owners":["devflow-core-skills"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"0e0098bd2a9583c54f56c7816725a26efc5e2dd25ad8078baa19b9c2ba0d7529","lines":133,"lexicalReferenceLines":{"delegation":[62],"skill_calls":[24],"claude_tools":[8,101],"legacy-skill-metadata":[7,8]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/dependency-research/references/evaluation-criteria.md","kind":"skill-reference","logicalId":"evaluation-criteria","owners":["devflow-core-skills"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"c0ac9bd604eb6732aa193ef24430af1d9251d45d0fca6f94ad7a693d9e8cfe39","lines":101,"lexicalReferenceLines":{"claude_tools":[40,69]}},{"path":"src/assets/skills/design-review/SKILL.md","kind":"skill","logicalId":"design-review","owners":["devflow-plan","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"c594e416f95dae573c79c82d337ac5a57050f7a5d5e61258e40f5d3674cccd18","lines":155,"lexicalReferenceLines":{"claude_tools":[5],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/design-review/references/anti-patterns.md","kind":"skill-reference","logicalId":"anti-patterns","owners":["devflow-plan","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"a4fb4bba2ec8049a6b7b8604c7fe43a1bd5147f3ee8e41060949d9998990d1b7","lines":207,"lexicalReferenceLines":{}},{"path":"src/assets/skills/docs-framework/SKILL.md","kind":"skill","logicalId":"docs-framework","owners":["devflow-core-skills","devflow-dynamic"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"ac657fe4c975718f1ecc14a9fe07a16184c77db0771789bbe6d82a3df281f666","lines":190,"lexicalReferenceLines":{"claude_tools":[5],"headless":[142,143],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/docs-framework/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-core-skills","devflow-dynamic"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"8adbe93fc7324a8bc4d954ce109f17188cc7e55c0fc5da4c5dc98f2e239b09a2","lines":381,"lexicalReferenceLines":{}},{"path":"src/assets/skills/docs-framework/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-core-skills","devflow-dynamic"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"b044fe291dabce4f2729897347bc3ae8f32eb7f3f5c2537a68bff74cb75f6eec","lines":221,"lexicalReferenceLines":{"claude_tools":[191]}},{"path":"src/assets/skills/documentation/SKILL.md","kind":"skill","logicalId":"documentation","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"3b52c97746d9b717437297d40c2d47fd0d406254a351ebbcf2e1c93c7e61ae22","lines":126,"lexicalReferenceLines":{"skill_calls":[10],"claude_tools":[5,99],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/documentation/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"cae594c0e012ad44867fd6d318db3192e182edec6909b75983fb9e075c729895","lines":190,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/documentation/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"281b798609dcf65a9f3646f2756fba8ee031f9f39721f9ed2036cb4b64750cfa","lines":189,"lexicalReferenceLines":{}},{"path":"src/assets/skills/documentation/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"28bed4cd148f0aab7192db2ce32223549eec3dc27c4733c09350cb0e58a5e6fe","lines":163,"lexicalReferenceLines":{}},{"path":"src/assets/skills/feature-knowledge/SKILL.md","kind":"skill","logicalId":"feature-knowledge","owners":["devflow-plan","devflow-implement","devflow-resolve","devflow-debug","devflow-explore","devflow-research","devflow-self-review","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"0c0c17609e816a428913940a643ed7db1e692ac4d0ef25d34ae1fc232ea1aee7","lines":341,"lexicalReferenceLines":{"claude_names":[291,295],"claude_tools":[6,7,8,9,32,41,43,44,84,244],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/gap-analysis/SKILL.md","kind":"skill","logicalId":"gap-analysis","owners":["devflow-plan","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"6904993beb56f763402c883d8d50d116b08cd97a2c99f04bda305f1bc6d10149","lines":151,"lexicalReferenceLines":{"skill_calls":[108],"claude_tools":[5],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/gap-analysis/references/check-layers.md","kind":"skill-reference","logicalId":"check-layers","owners":["devflow-plan","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"6e0865b85a533d0273854318d2db52dbf14cff7a1f06ad6df857d9fbcf0a0f62","lines":125,"lexicalReferenceLines":{}},{"path":"src/assets/skills/git/SKILL.md","kind":"skill","logicalId":"git","owners":["devflow-core-skills","devflow-debug","devflow-release"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"e1201ff408d9124b90d56ef86fb0a6da85a58f49428d87e775123346aadb210e","lines":283,"lexicalReferenceLines":{"skill_calls":[22],"claude_tools":[5],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/git/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-core-skills","devflow-debug","devflow-release"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"d328b75043f462d0d1ccec0dde5a4efcee0ddccd46ad4eeabb92c00271be84d6","lines":290,"lexicalReferenceLines":{}},{"path":"src/assets/skills/git/references/github-api.md","kind":"skill-reference","logicalId":"github-api","owners":["devflow-core-skills","devflow-debug","devflow-release"],"disposition":"target-reference-generation","sha256":"d909aecb94003a56ef3fd67f6d914c68b886c5a1f926a1afe845709ffade88ef","lines":666,"lexicalReferenceLines":{"claude_names":[132],"workflow":[409]},"specificAdaptation":"Adapt live report attribution; preserve GitHub mechanics/markers and coordinate tracker reference split."},{"path":"src/assets/skills/git/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-core-skills","devflow-debug","devflow-release"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"f6ca1d2bd8dba61c6ae1adc45377b4a38eea7d462b4c8ccbbbf6c168e0045a5c","lines":318,"lexicalReferenceLines":{"workflow":[105]}},{"path":"src/assets/skills/git/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-core-skills","devflow-debug","devflow-release"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"b987fa19718b21a8e5fa91d7abdfce6ac12c289e39e671ef440b13c08cde3d54","lines":16,"lexicalReferenceLines":{}},{"path":"src/assets/skills/git/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-core-skills","devflow-debug","devflow-release"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"b30262b922bcc930a868ad7c0f7b8eb130701a0372ad830a7708987e2b466806","lines":128,"lexicalReferenceLines":{}},{"path":"src/assets/skills/go/SKILL.md","kind":"skill","logicalId":"go","owners":["devflow-go"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"e196268c94725fa5d025b98e536720988aa72402cc7f4f893ce519913dde1a5d","lines":147,"lexicalReferenceLines":{"skill_calls":[25],"claude_tools":[5,60,61,131],"legacy-skill-metadata":[4,5,6]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools","activation"],"sourceActivationDeclared":true},{"path":"src/assets/skills/go/references/concurrency.md","kind":"skill-reference","logicalId":"concurrency","owners":["devflow-go"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"836ddfb7676dea70bf573558358221a686850c005e503b2f15a73a2345b54566","lines":335,"lexicalReferenceLines":{"workflow":[266]}},{"path":"src/assets/skills/go/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-go"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"03a8ca2d7e5b0e95d82cc6a6cf6eeff710615725b6e4544ce3abe218699b1ebf","lines":129,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/go/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-go"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"a85bacf6ae73f7ada372300ac23719a6c63bb7949a783a38708d2bd74584da5e","lines":278,"lexicalReferenceLines":{}},{"path":"src/assets/skills/go/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-go"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"4235526687b3859d3478dc0df0b497e1aa468b883d0ced5b0ffe85bf9e7221e2","lines":41,"lexicalReferenceLines":{}},{"path":"src/assets/skills/go/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-go"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"7e030d6293076fdb60a9ba0b978f32fc0806f0b231c081b8ae42425fbe5cbcb4","lines":262,"lexicalReferenceLines":{"claude_tools":[15]}},{"path":"src/assets/skills/java/SKILL.md","kind":"skill","logicalId":"java","owners":["devflow-java"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"d5de779cc53de6d6833c621e90ac2fed4c8b9f98b8ac06930cfe2cf70ec80a11","lines":148,"lexicalReferenceLines":{"skill_calls":[27],"claude_tools":[5],"legacy-skill-metadata":[4,5,6]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools","activation"],"sourceActivationDeclared":true},{"path":"src/assets/skills/java/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-java"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"c5bb3164de8697f963c4db181529651400ba48609f3c398ae12c45c5a58ba35e","lines":120,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/java/references/modern-java.md","kind":"skill-reference","logicalId":"modern-java","owners":["devflow-java"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"ae0fcca8746ce440e34147f0a3b48b27c93563e700bcbc77b928f8bcbf2491b9","lines":335,"lexicalReferenceLines":{}},{"path":"src/assets/skills/java/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-java"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"a294120ac20a79b15db5c3890917752a7cb1d9cddc5f8a877720928bf32dce19","lines":311,"lexicalReferenceLines":{}},{"path":"src/assets/skills/java/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-java"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"2abfffbd8720bd7b136d449d92a283d33c08883eb940ac4619e98f3db8bbe5c3","lines":44,"lexicalReferenceLines":{}},{"path":"src/assets/skills/java/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-java"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"f76166ef32d771cac5ed39a602eb4d41cd98885533a6a2ba561e704635fb3f26","lines":257,"lexicalReferenceLines":{}},{"path":"src/assets/skills/patterns/SKILL.md","kind":"skill","logicalId":"patterns","owners":["devflow-plan","devflow-implement","devflow-resolve","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"9d04c0abccc67b5c6a0cce0751a796974cc1fd57244365bdc50a3fdae5402201","lines":162,"lexicalReferenceLines":{"skill_calls":[20],"claude_tools":[5,35],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/patterns/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-plan","devflow-implement","devflow-resolve","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"9d7f8bb981474edf998feb1d350d6212faf69b5ddd234a2fd211a8606bcc823c","lines":1063,"lexicalReferenceLines":{"claude_tools":[39,60,967]}},{"path":"src/assets/skills/patterns/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-plan","devflow-implement","devflow-resolve","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"bff16c70ffd4da579626a46b1a3b6353cd88a56c0b2c36aa1d0692661152b44a","lines":483,"lexicalReferenceLines":{"claude_tools":[222]}},{"path":"src/assets/skills/performance/SKILL.md","kind":"skill","logicalId":"performance","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"426f9c5c96c734af75528652b9382b0bcc1ff2a4ea58b134d40eeea4d2bb2a8e","lines":135,"lexicalReferenceLines":{"skill_calls":[10],"claude_tools":[5,112],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/performance/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"64de81939e6048d54861a499833bd97d60fd04acf44ecce1bf359a6d50309272","lines":351,"lexicalReferenceLines":{}},{"path":"src/assets/skills/performance/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"0c6a96ed742ac7a9536ccd584e1fc86a39a61c9b844b8107b04d2134e042437b","lines":516,"lexicalReferenceLines":{}},{"path":"src/assets/skills/performance/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"0afb42a057bf4dce8cd91116a6fd7274ab829f11327887e2959bdc4db9855e04","lines":41,"lexicalReferenceLines":{}},{"path":"src/assets/skills/performance/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"8f00716eef5f54e6a2f3062cf011dfde97dbe84ca6999aa4a8cce6e8dfa986a6","lines":417,"lexicalReferenceLines":{}},{"path":"src/assets/skills/python/SKILL.md","kind":"skill","logicalId":"python","owners":["devflow-python"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"2d792e5ea8674c8b34769e04257e738746496dded4fb0c549a83da42561f771f","lines":156,"lexicalReferenceLines":{"skill_calls":[24],"claude_tools":[5,142],"legacy-skill-metadata":[4,5,6]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools","activation"],"sourceActivationDeclared":true},{"path":"src/assets/skills/python/references/async.md","kind":"skill-reference","logicalId":"async","owners":["devflow-python"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"e7cf8d3d10f4804b35379bfae1e2a5a13e00df0321cc00b2812e1164603ecfce","lines":255,"lexicalReferenceLines":{}},{"path":"src/assets/skills/python/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-python"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"80a2a86a75911057b866a88898bbbd6bdfb9978ffcf427ee75870990ec97a1da","lines":128,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/python/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-python"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"76e3887517f5f4291bd996601f5a769243240b46cab4e6855ae07602f9af82f6","lines":280,"lexicalReferenceLines":{}},{"path":"src/assets/skills/python/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-python"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"d91574d1e6a271c1b4e2bceccbb702f88e6b8b1354f481fb6ec5a686ccab8962","lines":41,"lexicalReferenceLines":{"skill_calls":[1]}},{"path":"src/assets/skills/python/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-python"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"9189d6289bd205b6e391310d1a4d2721a1c3c0f7bedceafe54cbfd7366e6c298","lines":272,"lexicalReferenceLines":{}},{"path":"src/assets/skills/qa/SKILL.md","kind":"skill","logicalId":"qa","owners":["devflow-implement","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"4331908ca16790d907d9fae5aabee59c0438ab6eee3d3b4943a4b2b764702fa7","lines":136,"lexicalReferenceLines":{"claude_tools":[7,77,92],"legacy-skill-metadata":[6,7]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/qa/references/browser-testing.md","kind":"skill-reference","logicalId":"browser-testing","owners":["devflow-implement","devflow-ambient"],"disposition":"target-reference-generation","sha256":"e2c2e922c89d0c9d3d3256fccb250a087a9ed486a188c2ef046a18af7cb63b07","lines":97,"lexicalReferenceLines":{"claude_tools":[20,60,62,65,66,67,68,69,70,77,79,91]},"specificAdaptation":"Adapt browser operations, server/process ownership and cleanup for selected Codex client/backend."},{"path":"src/assets/skills/qa/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-implement","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"d88a3e4093323bd695e71cc3f3bc85e59fe8e816d0cdb45d8b53875901bf362a","lines":118,"lexicalReferenceLines":{"skill_calls":[1]}},{"path":"src/assets/skills/qa/references/scenario-templates.md","kind":"skill-reference","logicalId":"scenario-templates","owners":["devflow-implement","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"b9bd9ac2cdb0e447f1d48d4e4fe20de9dce2733b762c1a8d98eceeea252143aa","lines":102,"lexicalReferenceLines":{"skill_calls":[1]}},{"path":"src/assets/skills/qa/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-implement","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"079a730a8f371f4c33d1e74b8707134c83de4ecbdcc171623e51da01ac5f3e00","lines":30,"lexicalReferenceLines":{"skill_calls":[1]}},{"path":"src/assets/skills/qa/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-implement","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"7d33bdc9cb6899048917e333dcfe002f1c9ff868247ac49b0b7ad0a9912683e3","lines":98,"lexicalReferenceLines":{"skill_calls":[1]}},{"path":"src/assets/skills/quality-gates/SKILL.md","kind":"skill","logicalId":"quality-gates","owners":["devflow-implement","devflow-self-review"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"f3a1098307d53a504be5c19a6819dbff2b09ff3ca12ee3590983dfd9a3384852","lines":152,"lexicalReferenceLines":{"claude_tools":[5],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/quality-gates/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-implement","devflow-self-review"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"24a36731420f7b423452940f9409761019f296de1f0151a1e9dfdca29b14fbc0","lines":405,"lexicalReferenceLines":{}},{"path":"src/assets/skills/quality-gates/references/report-template.md","kind":"skill-reference","logicalId":"report-template","owners":["devflow-implement","devflow-self-review"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"411efa37bb1a04d827deb951457e5d862bbbc5b15ed111c8b0a69611ab3bd999","lines":253,"lexicalReferenceLines":{}},{"path":"src/assets/skills/quality-gates/references/stub-detection.md","kind":"skill-reference","logicalId":"stub-detection","owners":["devflow-implement","devflow-self-review"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"578b0623ea5e818f9b066f8083adc1bb8cbafe376b00827553459278484c8998","lines":135,"lexicalReferenceLines":{}},{"path":"src/assets/skills/quality-gates/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-implement","devflow-self-review"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"d3759358fd4d08f008520fbc08bee8e65edca8712ce313246c842bd493654cde","lines":308,"lexicalReferenceLines":{}},{"path":"src/assets/skills/react/SKILL.md","kind":"skill","logicalId":"react","owners":["devflow-react"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"936491bc0c1e75388052ce962d1a4a2999f1b30b4760ec1cddc5211dfca4e3b3","lines":143,"lexicalReferenceLines":{"skill_calls":[29],"claude_tools":[5],"legacy-skill-metadata":[4,5,6]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools","activation"],"sourceActivationDeclared":true},{"path":"src/assets/skills/react/references/error-handling.md","kind":"skill-reference","logicalId":"error-handling","owners":["devflow-react"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"c28a440482230a2a86bf5493c8d178794ec98b7035f912107937569d3475e4a1","lines":179,"lexicalReferenceLines":{}},{"path":"src/assets/skills/react/references/forms.md","kind":"skill-reference","logicalId":"forms","owners":["devflow-react"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"f69f8b5967c528676aa067040616edc4ea654b44319f41a33995e453f26440d3","lines":214,"lexicalReferenceLines":{}},{"path":"src/assets/skills/react/references/hooks.md","kind":"skill-reference","logicalId":"hooks","owners":["devflow-react"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"0e12ee9682549efc005b73e7f6adef75b35b0c8c017c00c16866815660bb5c42","lines":193,"lexicalReferenceLines":{}},{"path":"src/assets/skills/react/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-react"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"4c57a2a9d0c1919cb8a3e8f41cbc21b060ac91768e708b731257b837f629ea5a","lines":1336,"lexicalReferenceLines":{}},{"path":"src/assets/skills/react/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-react"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"14fbfd1aef7240e4ebc27ccee90b07112a9bb79cc5fdc5aa215b48e57f993b15","lines":35,"lexicalReferenceLines":{}},{"path":"src/assets/skills/react/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-react"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"8faa050f44e6c168f921af1eb0f7222ea3952d888ca77c4191bbb5b2058bd2e5","lines":570,"lexicalReferenceLines":{}},{"path":"src/assets/skills/regression/SKILL.md","kind":"skill","logicalId":"regression","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"9ba81ef5f67050ac77b62c714da719db90e605c93bb12fcdd151aa7bf73c8756","lines":146,"lexicalReferenceLines":{"skill_calls":[10],"claude_tools":[5],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/regression/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"318ae4d7372268779dca0e4bca5cdd9763153ff73590ff81d378a92009fd5bf0","lines":237,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/regression/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"756aacb2a5acb964d7c38289e3447328581bd067d95a65bba503c32582ee5500","lines":226,"lexicalReferenceLines":{}},{"path":"src/assets/skills/regression/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"efbe5302cc802dd9259b92b978c7b06bd6d2c33ee1aeb902f7f9fc3ced6395fd","lines":225,"lexicalReferenceLines":{}},{"path":"src/assets/skills/reliability/SKILL.md","kind":"skill","logicalId":"reliability","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"65d275afe2acd7b45d6aadecd48d095cdd9db986c66d8236347273b4c98516c4","lines":153,"lexicalReferenceLines":{"skill_calls":[10],"claude_tools":[5,144],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/reliability/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"ba19e96f7204e59689904cf050df3f718ef27d1adee1015cf9cde23a3edfc484","lines":66,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/reliability/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"de212f2c81b6d2f9e37a755e5eb8f81b32375a72ef05a796e64f763644daeb3d","lines":151,"lexicalReferenceLines":{}},{"path":"src/assets/skills/reliability/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"de17ffc45f60c6f8002bc7325dfce108b8a0a57937e7d28a55a5d0bb5fd65256","lines":27,"lexicalReferenceLines":{}},{"path":"src/assets/skills/reliability/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-code-review","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"fef440056bdbb264116483378f883b424233abffc406939f3c5561f2341965f0","lines":125,"lexicalReferenceLines":{}},{"path":"src/assets/skills/research-codebase/SKILL.md","kind":"skill","logicalId":"research-codebase","owners":["devflow-research"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"b49afd52f18b76dd254f608cf2bb749e95564f4d3305fa4bb0f77076b294c2db","lines":135,"lexicalReferenceLines":{"claude_tools":[5,45,48,49,54,56,131,134],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/research-competitor/SKILL.md","kind":"skill","logicalId":"research-competitor","owners":["devflow-research"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"003892d1a24e746ce68791a247c2579cb16569b1b60df579913b1baf9898fde2","lines":145,"lexicalReferenceLines":{"claude_tools":[5],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/research-external/SKILL.md","kind":"skill","logicalId":"research-external","owners":["devflow-research"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"4cb1a7b2092de41e8ffcb3012ef267e64bfe33d147d939e81fbd60adf894fd9a","lines":141,"lexicalReferenceLines":{"claude_tools":[5,56],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/research-market/SKILL.md","kind":"skill","logicalId":"research-market","owners":["devflow-research"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"fdc873bdbb8ed4bd3a8b926aa19f443b56fb2ce8750261eb6d6c583de8abc129","lines":145,"lexicalReferenceLines":{"claude_tools":[5,53],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/research-technology/SKILL.md","kind":"skill","logicalId":"research-technology","owners":["devflow-research"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"3186c37c102f4133f9cd51348b8515fd2292c36bef5b332469bdf2c510839bc8","lines":180,"lexicalReferenceLines":{"claude_tools":[5,57,61,82,92,177],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/review-methodology/SKILL.md","kind":"skill","logicalId":"review-methodology","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"8f5bb1ba2b27edeefb6318039627e45c6cac759c5d36f8f5d50996db1c51b7fd","lines":121,"lexicalReferenceLines":{"skill_calls":[107,109,110,111,112,113,114,115,116,117,118,119],"claude_tools":[5],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/review-methodology/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"39001ac1ff336300412537b88dddd9c7944aa0ca3d0d910938354be24d9591f8","lines":186,"lexicalReferenceLines":{"claude_tools":[9,13]}},{"path":"src/assets/skills/review-methodology/references/report-template.md","kind":"skill-reference","logicalId":"report-template","owners":["devflow-code-review","devflow-ambient"],"disposition":"target-reference-generation","sha256":"fc51750f3d055bcfcd5d068cab769a4ea548c9c7968296f3759a96ce0a67db8a","lines":142,"lexicalReferenceLines":{"claude_names":[134]},"specificAdaptation":"Adapt live report footer attribution; preserve findings/report schema."},{"path":"src/assets/skills/review-methodology/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"95a1ab9886f5ae570c7e47fb88a13544b7205809e5ae254ac643781dda18cbb1","lines":125,"lexicalReferenceLines":{}},{"path":"src/assets/skills/rust/SKILL.md","kind":"skill","logicalId":"rust","owners":["devflow-rust"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"d0aa3dabd1435bc1c4a756ee40916b029b1a7185a7095daf8c8b5bd2ca5f792f","lines":148,"lexicalReferenceLines":{"skill_calls":[25],"claude_tools":[5],"legacy-skill-metadata":[4,5,6]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools","activation"],"sourceActivationDeclared":true},{"path":"src/assets/skills/rust/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-rust"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"a36954e0a678c98266552e765c0ea37699ed2ff3c2e52f29b583bf69e8c442cc","lines":131,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/rust/references/ownership.md","kind":"skill-reference","logicalId":"ownership","owners":["devflow-rust"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"5f32654dcd3a8c38c1bcbec5ba6d61304f468b03fb49e753a406928f4f375235","lines":278,"lexicalReferenceLines":{"claude_tools":[168]}},{"path":"src/assets/skills/rust/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-rust"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"19dc68b9191356a54754f9132604b251e4406c7f1676241fed26da779f057f96","lines":247,"lexicalReferenceLines":{}},{"path":"src/assets/skills/rust/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-rust"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"fd3175fcd6388d7748e5f4fe6b192d2b792cc5ae246197ac33344d1056c1ba1a","lines":46,"lexicalReferenceLines":{}},{"path":"src/assets/skills/rust/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-rust"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"06228fa43a579b988fcd4872317527baedaf23efbdbdd6ad305820cec352d7e2","lines":252,"lexicalReferenceLines":{"claude_tools":[163,166]}},{"path":"src/assets/skills/security/SKILL.md","kind":"skill","logicalId":"security","owners":["devflow-code-review","devflow-resolve","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"391e791ac3d3c030bbbec847b9bed28372e99398afbdb667a442adf1214f13f6","lines":121,"lexicalReferenceLines":{"skill_calls":[10],"claude_tools":[5,97],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false}]}}

[dean0x]

Evidence inventory, part 3/4. The current issue body owns the specification and decisions.

Machine-readable source roster and evidence — part 3/4

To reconstruct the complete inventory, read parts in order, merge fields into one object, and concatenate each named array from arrays. Source hashes refer to the recorded Devflow baseline. Historical 0.2.0 probes and the new 0.4.2 upgrade probes are distinguished.

{"snapshot":"devflow-codex-compatibility-2026-09-08","part":3,"parts":4,"fields":{"targetCompositionProbe":{"result":"pass for claude-code and codex","api":"compileFile(path, {vars: {harness}})","features":["imported parameterized helper","conditional branch","body and inline interpolation"],"constraints":["0.2.0 single braces","double braces rejected","frontmatter preserved despite runtime override","fenced interpolation literal"],"runtimeWorkflowValidation":false,"baselineNote":"Historical 0.2.0 probe; see mdsUpgradeProbes for the verified 0.4.2 counterpart."},"reconciliation":{"missingCommands":[],"undeclaredCommands":[],"missingAgents":[],"undeclaredAgents":[],"missingSkills":[],"undeclaredSkills":[],"missingRules":[],"undeclaredRules":[]}},"arrays":{"assets":[{"path":"src/assets/skills/security/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-code-review","devflow-resolve","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"a66c85a273e1dca15c6cf59a2db127376922dbcb4dec1204293e0d5e570c492d","lines":287,"lexicalReferenceLines":{}},{"path":"src/assets/skills/security/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-code-review","devflow-resolve","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"7123ff78fd7c7a96194d90b48e74710e562608c2483d0686a896eed989e6bcfa","lines":271,"lexicalReferenceLines":{}},{"path":"src/assets/skills/security/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-code-review","devflow-resolve","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"bc678306714d8bc2466b745787eca6eef23d6df3804f88cef56f1f9ad9b83b7b","lines":41,"lexicalReferenceLines":{}},{"path":"src/assets/skills/security/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-code-review","devflow-resolve","devflow-bug-analysis","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"f1b88a177f53e808586c3bcd2c3ba29309e2fd3e892fc8c9d4519588121ca4d3","lines":241,"lexicalReferenceLines":{}},{"path":"src/assets/skills/software-design/SKILL.md","kind":"skill","logicalId":"software-design","owners":["devflow-core-skills","devflow-self-review"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"e74d9dfbe92a75cdbd7ca8fc2186c04d3dc0ea4bed89042560a3e2a1c42c4145","lines":143,"lexicalReferenceLines":{"questions":[5],"claude_tools":[5,143],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false},{"path":"src/assets/skills/software-design/references/checklist.md","kind":"skill-reference","logicalId":"checklist","owners":["devflow-core-skills","devflow-self-review"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"13799927c647944f4218f07c72acdfe54145841cf73aee8afce6b2f3d18bdd25","lines":259,"lexicalReferenceLines":{}},{"path":"src/assets/skills/software-design/references/code-smell-violations.md","kind":"skill-reference","logicalId":"code-smell-violations","owners":["devflow-core-skills","devflow-self-review"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"eb714d8d430e67402d4e2105612771a088335971141379def00612d7ed62545e","lines":189,"lexicalReferenceLines":{}},{"path":"src/assets/skills/software-design/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-core-skills","devflow-self-review"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"d5676772bc58d54751c4034cba19fb98f3c4e033c4c8ffa4cc2fc37da1c117c8","lines":303,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/software-design/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-core-skills","devflow-self-review"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"b692d34cdbf7fdd923894e2865c3bb8a96d0fb86acb7ac7e8687f07e63dbe0b4","lines":359,"lexicalReferenceLines":{}},{"path":"src/assets/skills/software-design/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-core-skills","devflow-self-review"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"bea311abf7ee59309da25724040210e30092d294076bcc85d213396b92968bd0","lines":41,"lexicalReferenceLines":{}},{"path":"src/assets/skills/software-design/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-core-skills","devflow-self-review"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"eb6f15fbe2e52d493025473e68a1f375ef2fafed876544610e70113c03cb3c5d","lines":341,"lexicalReferenceLines":{}},{"path":"src/assets/skills/test-driven-development/SKILL.md","kind":"skill","logicalId":"test-driven-development","owners":["devflow-core-skills"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"d841ab907be7f80c8bbf0d61126b7486b6bf245ae4bcf4a825928ae1f7a3add4","lines":197,"lexicalReferenceLines":{"skill_calls":[185,193],"claude_tools":[5,28,37,39,49,51,55,96,97,115,121,126,127,148,157,159,193],"legacy-skill-metadata":[4,5,6]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools","activation"],"sourceActivationDeclared":true},{"path":"src/assets/skills/test-driven-development/references/rationalization-prevention.md","kind":"skill-reference","logicalId":"rationalization-prevention","owners":["devflow-core-skills"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"8be7ffdf34d933251684507e19ce31bbbf8fc48d742e2383cee6f15f7a5c85a9","lines":111,"lexicalReferenceLines":{}},{"path":"src/assets/skills/testing/SKILL.md","kind":"skill","logicalId":"testing","owners":["devflow-core-skills","devflow-code-review","devflow-ambient"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"c1c08e2fe3cdaf43492c8ab2b4fe364b7d4f208f059436db021d1a874131f251","lines":139,"lexicalReferenceLines":{"questions":[5],"claude_tools":[5,125],"legacy-skill-metadata":[4,5,6]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools","activation"],"sourceActivationDeclared":true},{"path":"src/assets/skills/testing/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-core-skills","devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"02dc72b1ec5775216e68bbcbc1fa7cc7afa3fa874160a0f747704205d5c25a56","lines":149,"lexicalReferenceLines":{}},{"path":"src/assets/skills/testing/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-core-skills","devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"a57000ea01bfb27c4346edbf811a2cf47dea1855617700c80cfe42f1cadbd0ea","lines":346,"lexicalReferenceLines":{}},{"path":"src/assets/skills/testing/references/report-template.md","kind":"skill-reference","logicalId":"report-template","owners":["devflow-core-skills","devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"8301266ea71aee40006e8bd0aece01ba32e7051076f950e7c53249f26127e2b7","lines":108,"lexicalReferenceLines":{}},{"path":"src/assets/skills/testing/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-core-skills","devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"950427d6efd35fea27ac16e52ac98c1a9670d780c5413904779df4e004f2d08a","lines":53,"lexicalReferenceLines":{"skill_calls":[1],"claude_tools":[13]}},{"path":"src/assets/skills/testing/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-core-skills","devflow-code-review","devflow-ambient"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"a282901eddb686c261f5d290ffc8efadbadba5d11f67137ee21ceeb39b0fa491","lines":322,"lexicalReferenceLines":{}},{"path":"src/assets/skills/typescript/SKILL.md","kind":"skill","logicalId":"typescript","owners":["devflow-typescript"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"15e81d000522845297feb83f788990b1ef45b04c18315fa7461c29ec92cdb3c7","lines":150,"lexicalReferenceLines":{"skill_calls":[25],"claude_tools":[5],"legacy-skill-metadata":[4,5,6]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools","activation"],"sourceActivationDeclared":true},{"path":"src/assets/skills/typescript/references/async.md","kind":"skill-reference","logicalId":"async","owners":["devflow-typescript"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"4f933350c1cc8b126ee729057275955f368aca6ac4b2d5bb0ba198748c8fdba2","lines":333,"lexicalReferenceLines":{}},{"path":"src/assets/skills/typescript/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-typescript"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"49a528fd3ea8145a5b74b0a8880d24f5fa9577bfda49eaa93f647e01e0069f6f","lines":440,"lexicalReferenceLines":{}},{"path":"src/assets/skills/typescript/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-typescript"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"71e65571aa4aaf27122c277863806511c964f9ef7a3af040b0ce570c774e6797","lines":41,"lexicalReferenceLines":{}},{"path":"src/assets/skills/typescript/references/type-guards.md","kind":"skill-reference","logicalId":"type-guards","owners":["devflow-typescript"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"1e6211d0076d4954daabd5f9268728b8e1aa8caa75ea1855dd10acf9b64d4139","lines":333,"lexicalReferenceLines":{}},{"path":"src/assets/skills/typescript/references/utility-types.md","kind":"skill-reference","logicalId":"utility-types","owners":["devflow-typescript"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"a06469329fa9a6c2ca17ceabf3ba63517c9e97cd486854b4768a04a825275879","lines":255,"lexicalReferenceLines":{}},{"path":"src/assets/skills/typescript/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-typescript"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"9fb0d0d7cb0aebba4d8bf8ee6875288150fe4ac39325ce7fcbb51c2a6e076a7d","lines":285,"lexicalReferenceLines":{}},{"path":"src/assets/skills/ui-design/SKILL.md","kind":"skill","logicalId":"ui-design","owners":["devflow-ui-design"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"ede7da6904efe6dd7e04098d90590557725349ebab04b368f09f42cca794b19d","lines":144,"lexicalReferenceLines":{"skill_calls":[33],"claude_tools":[5,130],"legacy-skill-metadata":[4,5,6]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools","activation"],"sourceActivationDeclared":true},{"path":"src/assets/skills/ui-design/references/detection.md","kind":"skill-reference","logicalId":"detection","owners":["devflow-ui-design"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"f632b6116e43c6a4d3710aff6512eeb69e35467755e38d5366c9aae33b00d620","lines":184,"lexicalReferenceLines":{"claude_tools":[3]}},{"path":"src/assets/skills/ui-design/references/patterns.md","kind":"skill-reference","logicalId":"patterns","owners":["devflow-ui-design"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"8fe54a7c92dff2cd9d3dda01f8570e5c0535f87aaa9308b9f54c676507fa54e5","lines":341,"lexicalReferenceLines":{}},{"path":"src/assets/skills/ui-design/references/sources.md","kind":"skill-reference","logicalId":"sources","owners":["devflow-ui-design"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"e1700738fb95192eb4b4e411af263da50393c640c0a44116a931bca9adb40525","lines":41,"lexicalReferenceLines":{}},{"path":"src/assets/skills/ui-design/references/violations.md","kind":"skill-reference","logicalId":"violations","owners":["devflow-ui-design"],"disposition":"shared-reference-content-with-tool-vocabulary-review","sha256":"786571f3e316f1ebb6a1003e8a8575f80a36776042c06dc52df771679de748f4","lines":312,"lexicalReferenceLines":{}},{"path":"src/assets/skills/worktree-support/SKILL.md","kind":"skill","logicalId":"worktree-support","owners":["devflow-plan","devflow-implement","devflow-code-review","devflow-resolve","devflow-debug","devflow-explore","devflow-research","devflow-release","devflow-self-review","devflow-bug-analysis","devflow-ambient","devflow-dynamic"],"disposition":"shared-body-target-metadata-and-reference-adapter","sha256":"8c91c4cff2f7482eb1236e7783ab8063b1a59563563be58c19cf92661be5480b","lines":92,"lexicalReferenceLines":{"claude_tools":[5],"legacy-skill-metadata":[4,5]},"sourceMetadataKeys":["name","description","user-invocable","allowed-tools"],"sourceActivationDeclared":false}],"publicCli":[{"name":"agents","path":"src/cli/commands/agents.ts","options":["--list","--set <agent>","--model <model>","--effort <level>","--reset","--yes"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"ambient","path":"src/cli/commands/ambient.ts","options":["--enable","--disable","--status"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"compliance","path":"src/cli/commands/compliance.ts","options":["--enable","--disable","--status","--set <list>"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"debug","path":"src/cli/commands/debug.ts","options":["--enable","--disable","--status"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"flags","path":"src/cli/commands/flags.ts","options":["--list","--status","--enable <ids>","--disable <ids>","--set <assignment>","--unset <ids>"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"hud","path":"src/cli/commands/hud.ts","options":["--status","--detail","--no-detail","--enable","--disable"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"init","path":"src/cli/commands/init.ts","options":["--scope <type>","--verbose","--plugin <names>","--ambient","--no-ambient","--memory","--no-memory","--hud","--no-hud","--knowledge","--no-knowledge","--learning","--no-learning","--rules","--no-rules","--proxy","--no-proxy","--compliance <list>","--no-compliance","--security <mode>","--hud-only","--recommended","--advanced","--reset"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"knowledge","path":"src/cli/commands/knowledge/index.ts","options":["--enable","--disable","--status"],"arguments":[],"subcommands":["list"],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"learning","path":"src/cli/commands/learning.ts","options":["--enable","--disable","--status","--list","--configure","--clear","--reset"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"memory","path":"src/cli/commands/memory.ts","options":["--enable","--disable","--status","--clear"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"proxy","path":"src/cli/commands/proxy.ts","options":["--enable","--disable","--status","--port <n>"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"rules","path":"src/cli/commands/rules.ts","options":["--enable","--disable","--status","--list"],"arguments":["[action]","[name]"],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"safe-delete","path":"src/cli/commands/safe-delete.ts","options":["--enable","--disable","--status"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"security","path":"src/cli/commands/security.ts","options":["--status","--enable","--managed","--user","--disable"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"skills","path":"src/cli/commands/skills.ts","options":[],"arguments":["<action>","[name]"],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."},{"name":"uninstall","path":"src/cli/commands/uninstall.ts","options":["--keep-docs","--scope <type>","--plugin <names>","--verbose","--dry-run"],"arguments":[],"subcommands":[],"disposition":"Preserve CLI behavior and route host-affecting configuration through selected harness/scope."}],"flags":[{"id":"tui","kind":"boolean","sourceTarget":{"type":"setting","key":"tui"},"meaning":"Flicker-free fullscreen rendering","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"tool-search","kind":"boolean","sourceTarget":{"type":"env","key":"ENABLE_TOOL_SEARCH"},"meaning":"Load tool schemas on demand instead of all at startup","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"lsp","kind":"boolean","sourceTarget":{"type":"env","key":"ENABLE_LSP_TOOL"},"meaning":"Enable Language Server Protocol integration","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"prompt-caching-1h","kind":"boolean","sourceTarget":{"type":"env","key":"ENABLE_PROMPT_CACHING_1H"},"meaning":"Extend prompt cache TTL from 5min to 1h","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"show-turn-duration","kind":"boolean","sourceTarget":{"type":"setting","key":"showTurnDuration"},"meaning":"Display timing info after each turn","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"clear-context-on-plan","kind":"boolean","sourceTarget":{"type":"setting","key":"showClearContextOnPlanAccept"},"meaning":"Clear context window when accepting a plan","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"disable-bundled-skills","kind":"boolean","sourceTarget":{"type":"setting","key":"disableBundledSkills"},"meaning":"Remove Claude Code's built-in skills and workflows (devflow provides its own)","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"pin-sonnet-4-6","kind":"boolean","sourceTarget":{"type":"env","key":"ANTHROPIC_DEFAULT_SONNET_MODEL"},"meaning":"Pin the default Sonnet model to claude-sonnet-4-6","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"max-concurrent-subagents","kind":"number","sourceTarget":{"type":"env","key":"CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS"},"meaning":"Maximum number of subagents Claude Code will spawn concurrently","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"brief","kind":"boolean","sourceTarget":{"type":"env","key":"CLAUDE_CODE_BRIEF"},"meaning":"Reduce verbosity of Claude Code output","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"thinking-summaries","kind":"boolean","sourceTarget":{"type":"setting","key":"showThinkingSummaries"},"meaning":"Show thinking summaries during reasoning","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"subprocess-env-scrub","kind":"boolean","sourceTarget":{"type":"env","key":"CLAUDE_CODE_SUBPROCESS_ENV_SCRUB"},"meaning":"Strip cloud credentials from subprocesses","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"disable-nonessential-traffic","kind":"boolean","sourceTarget":{"type":"env","key":"CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC"},"meaning":"Suppress usage metrics telemetry","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"forked-subagents","kind":"boolean","sourceTarget":{"type":"env","key":"CLAUDE_CODE_FORK_SUBAGENT"},"meaning":"Better subagent perf on external builds","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"disable-adaptive-thinking","kind":"boolean","sourceTarget":{"type":"env","key":"CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING"},"meaning":"Disable adaptive reasoning on Opus/Sonnet 4.6","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"always-thinking","kind":"boolean","sourceTarget":{"type":"setting","key":"alwaysThinkingEnabled"},"meaning":"Enable extended thinking by default","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"disable-git-instructions","kind":"boolean","sourceTarget":{"type":"env","key":"CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS"},"meaning":"Remove git workflow instructions from system prompt","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"disable-compact","kind":"boolean","sourceTarget":{"type":"env","key":"DISABLE_COMPACT"},"meaning":"Disable automatic context compaction","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"disable-1m-context","kind":"boolean","sourceTarget":{"type":"env","key":"CLAUDE_CODE_DISABLE_1M_CONTEXT"},"meaning":"Disable the 1M-token context window experiment (v2.1.223+)","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"disable-autoupdater","kind":"boolean","sourceTarget":{"type":"env","key":"DISABLE_AUTOUPDATER"},"meaning":"Prevent automatic update checks","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"agent-teams","kind":"boolean","sourceTarget":{"type":"env","key":"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS"},"meaning":"Enable Claude Code experimental Agent Teams","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"enable-todo-tools","kind":"boolean","sourceTarget":{"type":"env","key":"CLAUDE_CODE_ENABLE_TODO_TOOLS"},"meaning":"Restore Todo and TaskCreate tools removed by default in newer models","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"suppress-attribution","kind":"boolean","sourceTarget":{"type":"setting","key":"attribution"},"meaning":"Remove AI-attribution labels from git commits and pull requests","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"subagent-spawn-depth","kind":"number","sourceTarget":{"type":"env","key":"CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH"},"meaning":"Maximum depth of nested subagent spawning","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"workflow-size-guideline","kind":"enum","sourceTarget":{"type":"setting","key":"workflowSizeGuideline"},"meaning":"Guide Claude on the expected size of workflow plans","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"default-model","kind":"string","sourceTarget":{"type":"env","key":"ANTHROPIC_DEFAULT_MODEL"},"meaning":"Override the default model for Claude Code","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"goal-checkin-minutes","kind":"number","sourceTarget":{"type":"env","key":"CLAUDE_CODE_GOAL_CHECKIN_MINUTES"},"meaning":"Interval in minutes for Claude to check in on task goals","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"spellcheck","kind":"string","sourceTarget":{"type":"setting","key":"spellcheck"},"meaning":"Custom spellcheck command for Claude Code","dispositionReference":"report: CLI, settings, state and Git operations"},{"id":"view-mode","kind":"enum","sourceTarget":{"type":"setting","key":"viewMode"},"meaning":"Interface view mode (default / verbose / focus)","dispositionReference":"report: CLI, settings, state and Git operations"}],"hudComponents":["directory","gitBranch","gitAheadBehind","diffStats","model","contextUsage","versionBadge","sessionDuration","usageQuota","todoProgress","configCounts","learningCounts","sessionCost","releaseInfo","worktreeCount"],"gitOperations":["ensure-pr-ready","validate-branch","setup-task","fetch-issue","fetch-issues-batch","post-review-summary","manage-debt","check-ci-status","create-release","gather-release-evidence","learn-conventions","fetch-review-threads","resolve-review-threads","post-resolution-summary","check-merge-readiness","backlink-shipped-issues","ensure-traceable-issue","post-wave-report"],"sourceFiles":[{"path":"src/cli/agents-view/index.ts","sha256":"9c81415aa82d68199bdf553a929a629b31ff5fd9ce3d3bee542714c908164fc1","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/agents-view/render.ts","sha256":"3176c7a96caa4445794c17200adb2a49a52eda88474d01806e56c720e24d3714","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/agents-view/state.ts","sha256":"3c8fa995c37f6e6cc3dcc9fd4f303307cccc9409d4f8c82c747cccda4c401c11","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/agents-view/terminal.ts","sha256":"e4f8e11e87745ac4523f2774ca9a299be843fd5a11809d547161461c9bd80981","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/agents.ts","sha256":"0a8088b77704c7dfbf7a4c34f0d3a429028c1282a5f7703bbc0db9680d027534","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/ambient.ts","sha256":"d47c56733af022063465b920472ca20db2e772c59650c1d1613e39e8dbcd062f","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/attribution-prompts.ts","sha256":"47dad573492147c394fa576402944dea3421253c8f188778eede03d71d75d673","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/capture.ts","sha256":"f555ee65808a1043e082a5eb71a67f9a59d3935bfad912373cc658561544a07f","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/compliance-prompts.ts","sha256":"c80128999b3f4839082430627f71f9ca841c5e24cd9221318c5ac46812f570df","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/compliance.ts","sha256":"01ab71fbc6cd3f2fc7dd12643ea248d17f8744d0b2e56fad832e7ae7b90ffb68","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/context.ts","sha256":"d770c5a22853dd60b95c3d4dd9e1e6c3830688a0f7d3551cbda3bc671240a2ea","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/debug.ts","sha256":"5ba2b2221a13ca7bf18304ff7157051cf7eb35121db8375c773e0810594a7c88","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/flags.ts","sha256":"d0cc274fabf65f1cc325a6f056c42135e65e8b75e2edb3ec15510c14132064d8","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/hud.ts","sha256":"5c516db7a868273bed99558f3092a5ef40bd207912c2c9a67243703ed5feb5c1","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/init-seed.ts","sha256":"5c95f7374d51998de6f0690baf6f8f7d6c4088fbe6790c64c7f92b8e378d114a","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/init.ts","sha256":"10d22ac3029398892c5e2af4ad63df33bddd60cea797724325c88eea403ae48a","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/knowledge/index.ts","sha256":"63d01345530673c409dfc5b94526929c4152a714b5b2fbf7457dec16078099c8","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/knowledge/list.ts","sha256":"cf32e481265dc19d58de0bc40b4d14eac0af2e928e4b83c4ee671debcc2db1a6","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/knowledge/toggle.ts","sha256":"b4ff1db8a1d7a88ef247cb8627109ff5d6f9d0862f61b109eca4f6d60bf853da","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/learning.ts","sha256":"aa1f7309f7c9949c433fa510af6c4f87872fb830e6bbaf94b782b571f7c9c5df","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/legacy-hooks.ts","sha256":"5444bf0f902d75e5e73a06f2216fcc4e91336c8fe75069092345b81e390b49ba","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/memory.ts","sha256":"86920dfb24b1f48c97f2227bb999ceccf15903b019a1c82a4efd118f815cdfb1","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/prompt-io.ts","sha256":"3c0c8285735b6556aefbc9e01411753d758c1475573706545782cb7d5060bbfe","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/proxy.ts","sha256":"ffd205b1793f102f2643229f132944f9a926fc3e5cb2749c85cb5cb7f2d7eeca","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/rules.ts","sha256":"5135c95e61b254d3254ad10570d517e50a0dffa6e4900770b124a751ee749899","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/safe-delete.ts","sha256":"ed945bdf3e19df56cd563b7e9ebc9f5b7ce545f125cde90c6138d0731a9133ef","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/security.ts","sha256":"60ff76e837ac687f9ac8804ce6bc963de68981fb9e4ffed1de63d7418e0ba357","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/skills.ts","sha256":"3ef8b8d89b17de943f84293cc0adb1fff97cf9f0e0ea5f4415680262aef7a35d","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/commands/uninstall.ts","sha256":"d96cbe693e742e6e7cc3dfc3eb94eda233f41d93e4c9cd4eaa937f9fc9c70bfc","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/flags-view/index.ts","sha256":"4f5f241efe84060ffa28cc6d578cf012db3e641c1a6ff80440557bd7143f2d97","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/flags-view/render.ts","sha256":"d89f8158783db3a19ae45a1843751879ecd2357ca82b73f4a8874ebedd053958","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/flags-view/state.ts","sha256":"a2a0a2e5740d7f0c1ab55102df9ad0f1ec11428abbd3081d296d71882e2c40b3","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/flags-view/terminal.ts","sha256":"f13fa2ef5f5e43c27d955c3090bf5d6fc1250bd5b6b4cbbf9ee4a23f5a09785b","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/tui/cells.ts","sha256":"0b895b333aff011edeb3a4549fd1566797fe260ab5710dd761e7bdcbb654674f","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli/tui/terminal.ts","sha256":"c3e96e57371abbd4c15b45c9c63eb055e1494302bb7d92282122ccc6ae4d0819","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/cli.ts","sha256":"20ad7003fa99c237982d6451f9d4e408772631ddf6142ab5e2a2e2b6c0b2426d","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/agent-frontmatter.ts","sha256":"33740da7c75027326aaba514da106d907f992e90534c3193fc40339dce0bdd59","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/agent-models.ts","sha256":"589e5c2988c48d09cf3b516cec6c53b1a973af7eaf1a335f046c614ea2529835","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/agent-state.ts","sha256":"efacf2b7e2071a71b24b698dfc6394960cfed1fbb17b782f3ddf2188d204576e","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/ansi.ts","sha256":"6f79763548d89e1b63323dd781f88a4699fee3c76b08e6564030b58f13611d4c","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/assets.ts","sha256":"2f46d9c6a3bfa7c7005383f1cd0456f3ed27a104e7f0f795ab15a7e9d4800f67","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/cache.ts","sha256":"ee3b1fc7fc984a7eacd6ee7a138903578620ff536a081ce6f14496fa18bfe14d","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/codex-auth-inspect.ts","sha256":"da563d9b12c37f664bc55cb5b73aa68f1445aa4a760473c0c9f1cc99d687e2ec","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/compliance-compose.ts","sha256":"3c0799021d0eabe9fea6e0ff4df9ecc12c3f208d05d3b40c11cce0690eae5212","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/compliance.ts","sha256":"96c4ddee0a659421ab34d466c38020fd814aab52dd3f41ce50f7a53eafbd36aa","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/external-models.ts","sha256":"05937b2dd6746f4691bceac40e4e38b242863e520ace7414a2f2bcc9531df4d6","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/feature-config.ts","sha256":"494d61f8fad6041a5015e7b364c5673fca864fd9a95a9eedbdedf4deb434c9c0","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/flags.ts","sha256":"48696874b2b24a6929ba8a492bffc7a6d12d674b6648d52e0175f3686afc5d5b","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/fs-atomic.ts","sha256":"165d4039aef475c996cb8d5f26c5d47da78d67628d0eb32ba7b2b53d76020de1","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/git.ts","sha256":"a141e8011f295520d4e831b1f6e9774d5aab8cb59871388600405582f1c0226e","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/learning-queue-cleanup.ts","sha256":"b4b2a78989e1b4547f065e034aab29ced4ee088319ad29f2e30d57df727ef0e3","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/learning-tuning-config.ts","sha256":"78f85bdf5809e9c4be4436806e5b8a8f1aaa836f38ddab7dda22755f564587f5","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/manifest.ts","sha256":"0d01fd5d6c49ca13ef5ce93d4a79d38ccad325a982fa71c3d47948f75d0818ce","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/migrations.ts","sha256":"9e9c175838dd31409d8262581102a32abbbfd5343895a1496b9b5fe57d3ae7e5","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/model-discovery.ts","sha256":"c2c2061b2618e5e71217c1d3d6f51928382a82fe9172b15ef4165a77e8c10b14","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/observation-io.ts","sha256":"46746251900588cae824b394439067c12d49e46fb404577030a908aef11cdbd8","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/observations.ts","sha256":"9cdfe2d91d1bdd1059831ae0841bed6c4a843798a7c2deeb16b5d2c1ce071636","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/orphan-sweep.ts","sha256":"faad71d0e786c85dc000f8cd446bfc39f5b23ca0e7823a12dfa5845e293286fe","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/paths.ts","sha256":"7f8608b9c80e44f85e32a93748a2f4761fc3d48b19844ac91e5de70be37869ad","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/plugins.ts","sha256":"c8c3cb45f221b0c183c3f02f5db379b30d78a9cbafb9bef657684ad1491d2f29","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/project-paths.ts","sha256":"51ab65c263db63bc33e0e3d01ba84a7d751a89ddb7de2fb3bb09fbaed7e705ec","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/proxy-log.ts","sha256":"a1e9dff1b6cf945ae01b4f65a548070b5b22dc4a45f5b32c797c258db0189219","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/proxy-state.ts","sha256":"df92837d9c4fb1604c82066fe77a232ec2092cc1e09c44baf690102b30400bfa","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/safe-delete-install.ts","sha256":"62d4fe05c297b25f8967c811fd34ac6b0e694de4fc349c18cce9f9e059f91fed","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/safe-delete.ts","sha256":"cfd8991bdac90f9f9882985c03033d36b3bb1007a7367779e32f4283c95d56c4","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/core/teammate-mode-cleanup.ts","sha256":"55c11d39935bf378393e10085a330e1325bd302338c89ca22e325295b5c38129","ownershipReview":"shared-core-or-cli: audit target assumptions before reuse"},{"path":"src/hud/colors.ts","sha256":"5ff8444d301b27ee8b7a5f501da3ae4698268cf1f2c71648a8a6888df87aa7f2","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/config-counts.ts","sha256":"c190bebbda0ea5866652459ae4d4e02f266b8713b57244cbccc007ac0df01f07","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/context-usage.ts","sha256":"ee2af38fddfca6b33834bbc6b8eb0e23c0c6c15ed37e04d11259c7e53507e50d","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/diff-stats.ts","sha256":"bdb04bef380a583b1d50eaee274e5cd0cef21ebf7b08b0b7b28c079b8cb1c38d","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/directory.ts","sha256":"ffd2e04ffd37a1733226086abfadc81b714efed38cff994cb9f8101628982a62","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/git-ahead-behind.ts","sha256":"73aab7a89446a2baf23019efecaf8f79a7c24330d93c699e971b503d506d293f","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/git-branch.ts","sha256":"0914a03fd1f1cd4709e6595411dbb38a579774cee195ef555f12016ed3f3e22d","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/learning-counts.ts","sha256":"bc6ee169d220591605d0368c8edd9f14d6b5b27e9b6a560aa3288109a2f3a2cf","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/model.ts","sha256":"40192fc4fc5c86e541d988f24bb72d75e3a39057e03dcf8f28b4b2394bd23677","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/release-info.ts","sha256":"4408dbebf52f3ecd94c8d04e944ec4fac9eede9d2b77cec9a96b2e3160425b3e","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/session-cost.ts","sha256":"ce28e9034ee141ae6b79fa7c542fad6851d9bdda6ec58aaf1fd66e8f83bd420a","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/session-duration.ts","sha256":"b44471664bb613fd278794d30bee6a7d42e1b6dd1c9a794f6f46cc10374f6d7a","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/todo-progress.ts","sha256":"8f42a673bfccde0e07c9e6ffe2a7be0cb6b59abe57e4fa66b4bd0da05b9765e1","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/usage-quota.ts","sha256":"f08dd1d6b7c1984ec3267ae70faae2fed981a7dbfc92722c0f235f3dd78e492a","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/version-badge.ts","sha256":"2615c087db3883de967b04a602f42e7630946d74fdfd9a6b52879589dc41b7a4","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/components/worktree-count.ts","sha256":"2f32e8eac26f8b7a5373e0a597b3f7dd07bb4ced1beeb6ef520de10a98f8f200","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/config.ts","sha256":"877432712a7966fd66d23f25c57845678683c224220f8f9ad556d114858a0d5d","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/cost-history.ts","sha256":"8c6364e1394f16b8a7f9c5619ff61089cd00adf8b6652a77a026b77206dd10a5","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/git.ts","sha256":"139f777228df75da9316bac1a33fe03372cd93b29394ff12783759785cef3309","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/index.ts","sha256":"a1313f6ffe1a31a3b5233191285729f389c92cd591dd78141693a2243f691284","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/render.ts","sha256":"28a489fde928d4e0015f48a95032472d6739c361a017388ab5e6a56ab52aac84","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/stdin.ts","sha256":"e97d7bad65fcadbf88654a3a727d848c1eb4e5ec4ce3cbd36244e09792e424ea","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/transcript.ts","sha256":"1115457107516c374e12a134bec7cf4e149649c8b108407432833e6a6c321eea","ownershipReview":"hud-data-and-renderer"},{"path":"src/hud/types.ts","sha256":"6d41bbac78d02582a04f432fd26c11abeeed1f36ce4260e33f2196337133934c","ownershipReview":"hud-data-and-renderer"},{"path":"src/targets/claude-code/claude-paths.ts","sha256":"6bc8afa8e1b8cc982f30cc3199b21d293cb0f0e45bfd8eb6f155c765b14635bb","ownershipReview":"claude-adapter"},{"path":"src/targets/claude-code/compliance-install.ts","sha256":"ea911c88095f95e3d9d6ba659e94a0b10633ce14eaaeb44c968695b6ecee487c","ownershipReview":"claude-adapter"},{"path":"src/targets/claude-code/hooks.ts","sha256":"66658ecb606f02214195a0e5fef3cdee0929cb0d25abfd52e1ebf6fb50a702d5","ownershipReview":"claude-adapter"},{"path":"src/targets/claude-code/installer.ts","sha256":"6d0dd1f7d75a0a7949eb93dec4d096386db3b2e920a9c6a1ea4e15c7bde4061f","ownershipReview":"claude-adapter"},{"path":"src/targets/claude-code/legacy.ts","sha256":"64df0be04823108efdd23a79ad90ea13e89194469ebedf149a82891e4ba3f36b","ownershipReview":"claude-adapter"},{"path":"src/targets/claude-code/post-install.ts","sha256":"f9655a1d1ce5c2c3df48780ac2e6f957355df1bd96700fd631db64f9f9160240","ownershipReview":"claude-adapter"}],"buildAndConfigFiles":[{"path":"package.json","sha256":"8a42100427ceefbcbecff8512dd93cafe31503107b39ddd0506a76262b32bf92"},{"path":"scripts/build-mds.ts","sha256":"81278372160d34f17d6c91e008e6a0f527b870ff9d54409b331488e8965e9df9"},{"path":"scripts/update-golden.ts","sha256":"3b8a3d65a2f588cabec46235dfe30afacec60395b7da15bb4d64fb2c50ce7e32"},{"path":".github/workflows/ci.yml","sha256":"c01984579d1cc86c2372a5d1886151160559f2313516b181e909f67c47e48e39"},{"path":".github/workflows/release.yml","sha256":"3638920a26ce776512f29d60e46ab7e888dda394c06b74cdfd950ea4c851ac0d"},{"path":".release/RELEASE-FLOW.md","sha256":"914af2ae742dc9b60ff356081d9b38a461c2aa6a4bc9af54082e6d5ac3cd65f6"},{"path":"src/targets/claude-code/templates/claudeignore.template","sha256":"cf3af62e2ba7bf9fe9d339948c21b7e3ac26574a889755ee03f1f68ca50eb6de"},{"path":"src/targets/claude-code/templates/managed-settings.json","sha256":"7d84324b6eaac37469a6d8571b50a3b708532e5430f3da53b5a32a94f3997640"},{"path":"src/targets/claude-code/templates/settings.json","sha256":"90fbbeb8e02ee0b382839e050c2469f91077fa453b4eb2c327ac34d649e917cb"}],"existingTestFiles":["tests/agent-frontmatter-injection.test.ts","tests/agent-frontmatter.test.ts","tests/agent-models.test.ts","tests/agent-name-guards.test.ts","tests/agent-state.test.ts","tests/agents-command.test.ts","tests/agents-render.test.ts","tests/agents-state.test.ts","tests/agents-terminal.test.ts","tests/ambient.test.ts","tests/attribution-prompts.test.ts","tests/bug-analysis/structural.test.ts","tests/build-mds.test.ts","tests/build.test.ts","tests/cache.test.ts","tests/capture-hooks.test.ts","tests/capture.test.ts","tests/cli-unknown-command.test.ts","tests/codex-auth-inspect.test.ts","tests/compliance-cli.test.ts","tests/compliance-compose.test.ts","tests/compliance-e2e.test.ts","tests/compliance-install.test.ts","tests/compliance-prompts.test.ts","tests/compliance-rules-enable.test.ts","tests/compliance.test.ts","tests/config-disable-guards.test.ts","tests/core-paths-assets.test.ts","tests/cost-history.test.ts","tests/debug.test.ts","tests/decisions/apply-decisions-skill.test.ts","tests/decisions/cli-subcommands.test.ts","tests/decisions/command-adoption.test.ts","tests/decisions/config.test.ts","tests/decisions/decisions-format.test.ts","tests/decisions/decisions-usage-scan.test.ts","tests/decisions/helpers.test.ts","tests/decisions/index-content.test.ts","tests/decisions/json-helper-write-exclusive.test.ts","tests/decisions/learning-curation.test.ts","tests/decisions/ledger-ops.test.ts","tests/decisions/observations-schema.test.ts","tests/decisions/render-decisions.test.ts","tests/decisions/review-command.test.ts","tests/decisions/safe-path.test.ts","tests/eager-memory-refresh.test.ts","tests/external-models.test.ts","tests/flags-cli.test.ts","tests/flags-view-render.test.ts","tests/flags-view-state.test.ts","tests/flags-view-terminal.test.ts","tests/flags.test.ts","tests/fs-atomic.test.ts","tests/git-agent.test.ts","tests/git.test.ts","tests/goldens/git-agent-golden.test.ts","tests/goldens/github-status-lines.test.ts","tests/guards/agent-source-resolver.test.ts","tests/guards/extended-references.test.ts","tests/guards/literal-agent-paths.test.ts","tests/guards/numeric-floor-manifest.test.ts","tests/guards/retired-wording.test.ts","tests/hud-components.test.ts","tests/hud-config-counts.test.ts","tests/hud-enable-selfheal.test.ts","tests/hud-learning-counts.test.ts","tests/hud-render.test.ts","tests/hud-transcript.test.ts","tests/hud.test.ts","tests/init-e2e-flags.test.ts","tests/init-logic.test.ts","tests/init-proxy.test.ts","tests/init-review-publication.test.ts","tests/init-seed.test.ts","tests/installer-new.test.ts","tests/integration/ambient-activation.test.ts","tests/integration/clause-ii-file-residue.test.ts","tests/integration/helpers.test.ts","tests/integration/hud-git.test.ts","tests/integration/pack-install.test.ts","tests/integration/subagent-skill-preload.test.ts","tests/learning-agent.test.ts","tests/learning-config.test.ts","tests/manifest.test.ts","tests/memory.test.ts","tests/migrations.test.ts","tests/model-discovery.test.ts","tests/orphan-sweep.test.ts","tests/packaging.test.ts","tests/paths.test.ts","tests/plugins.test.ts","tests/post-install-merge.test.ts","tests/project-paths.test.ts","tests/proxy-enable.test.ts","tests/proxy-log.test.ts","tests/proxy-state.test.ts","tests/proxy.test.ts","tests/queue-append.test.ts","tests/redact-secrets.test.ts","tests/registry-integrity.test.ts","tests/resolve/bug-analysis-fallback.test.ts","tests/resolve/convergence-detection.test.ts","tests/resolve/decisions-citation.test.ts","tests/resolve/duplicate-verdict.test.ts","tests/review/convergence-detection.test.ts","tests/rules.test.ts","tests/safe-delete-command.test.ts","tests/safe-delete-install.test.ts","tests/safe-delete.test.ts","tests/seams/command-agent-input.test.ts","tests/security-command.test.ts","tests/shell-hooks.test.ts","tests/skill-namespace.test.ts","tests/skill-references.test.ts","tests/skills.test.ts","tests/skim-agent.test.ts","tests/teammate-mode-cleanup.test.ts","tests/tui-cells.test.ts","tests/tui-terminal.test.ts","tests/uninstall-logic.test.ts"],"compilerProbes":[{"file":"src/assets/commands/bug-analysis.mds","ok":true,"bytes":18001,"warnings":0,"dependencies":3},{"file":"src/assets/commands/code-review.mds","ok":true,"bytes":20988,"warnings":0,"dependencies":4},{"file":"src/assets/commands/debug.mds","ok":true,"bytes":11510,"warnings":0,"dependencies":2},{"file":"src/assets/commands/dynamic-build.mds","ok":true,"bytes":64616,"warnings":0,"dependencies":6},{"file":"src/assets/commands/dynamic-plan.mds","ok":true,"bytes":24182,"warnings":0,"dependencies":3},{"file":"src/assets/commands/dynamic-profile.mds","ok":true,"bytes":12466,"warnings":0,"dependencies":1},{"file":"src/assets/commands/dynamic-tickets.mds","ok":true,"bytes":30745,"warnings":0,"dependencies":4},{"file":"src/assets/commands/explore.mds","ok":true,"bytes":9430,"warnings":0,"dependencies":2},{"file":"src/assets/commands/implement.mds","ok":true,"bytes":25747,"warnings":0,"dependencies":3},{"file":"src/assets/commands/plan.mds","ok":true,"bytes":23281,"warnings":0,"dependencies":3},{"file":"src/assets/commands/research.mds","ok":true,"bytes":9058,"warnings":0,"dependencies":2},{"file":"src/assets/commands/resolve.mds","ok":true,"bytes":37113,"warnings":0,"dependencies":4},{"file":"src/assets/commands/self-review.mds","ok":true,"bytes":10637,"warnings":0,"dependencies":2},{"file":"src/assets/agents/code.md","ok":false,"code":"mds::not_mds","error":"not an MDS file: /Users/dean/Sandbox/devflow/src/assets/agents/code.md"},{"file":"src/assets/skills/react/SKILL.md","ok":false,"code":"mds::not_mds","error":"not an MDS file: /Users/dean/Sandbox/devflow/src/assets/skills/react/SKILL.md"},{"file":"src/assets/skills/qa/references/browser-testing.md","ok":false,"code":"mds::not_mds","error":"not an MDS file: /Users/dean/Sandbox/devflow/src/assets/skills/qa/references/browser-testing.md"},{"file":"src/assets/skills/compliance/SKILL.md","ok":false,"code":"mds::not_mds","error":"not an MDS file: /Users/dean/Sandbox/devflow/src/assets/skills/compliance/SKILL.md"}],"openDecisionIds":[1,2,3,4,5,6,7,8],"gapIds":["G01","G02","G03","G04","G05","G06","G07","G08","G09","G10","G11","G12","G13","G14"]}}

[dean0x]

Evidence inventory, part 4/4. The current issue body owns the specification and decisions.

Machine-readable source roster and evidence — part 4/4

To reconstruct the complete inventory, read parts in order, merge fields into one object, and concatenate each named array from arrays. Source hashes refer to the recorded Devflow baseline. Historical 0.2.0 probes and the new 0.4.2 upgrade probes are distinguished.

{"snapshot":"devflow-codex-compatibility-2026-09-08","part":4,"parts":4,"fields":{"securityTemplate":{"path":"src/targets/claude-code/templates/managed-settings.json","entryCount":154,"categories":{"Bash":129,"Read":25},"entries":[{"pattern":"Bash(rm -rf /*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -rf ~*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -rf .*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(* rm -rf /*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -r /*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -r ~*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -r .*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -fr /*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -fr ~*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -fr .*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -f /*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -f ~*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -f .*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(dd if=*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(dd*of=/dev/*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(mkfs*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(fdisk*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(parted*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(shred*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(> /dev/sda*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(> /dev/nvme*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(sh -c *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(bash -c *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(curl * | bash*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(curl * | sh*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(wget * | bash*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(wget * | sh*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(fetch | sh*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(lynx -source | bash*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(base64 -d | bash*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(base64 -d | sh*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(base64 --decode | bash*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(eval *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(exec *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(sudo *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(su *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(doas *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(pkexec *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(passwd*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(useradd*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(userdel*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(usermod*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(groupadd*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(chmod*777*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(chmod*666*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(chmod -R 666*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(chmod a+w*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(chown*root*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(chgrp*root*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(kill -9 *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(kill -KILL *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(killall *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(pkill -9 *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(pkill *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(xkill*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(reboot*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(shutdown*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(halt*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(poweroff*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(init 0*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(init 6*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(systemctl*stop*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(systemctl*disable*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(systemctl*mask*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(service*stop*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(nc -l*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(nc -e*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(netcat -l*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(ncat -l*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(socat*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(telnet*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(python -c *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(python3 -c *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(php -r *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(perl -e *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(ruby -rsocket*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(nmap*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(masscan*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(ufw disable*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(iptables -F*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(iptables --flush*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(insmod*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rmmod*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(modprobe*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(sysctl -w *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(docker run --privileged*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(docker run -v /:/host*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(docker run --pid=host*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(docker run --net=host*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(nsenter*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(crontab*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm /var/log*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -rf /var/log*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -r /var/log*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -f /var/log*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -fr /var/log*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(> /var/log*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(truncate /var/log*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(history -c*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(history -w*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm ~/.bash_history*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -f ~/.bash_history*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm ~/.zsh_history*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rm -f ~/.zsh_history*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(unset HISTFILE*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(curl 169.254.169.254*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(wget 169.254.169.254*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(rsync --daemon*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(sftp *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(ssh -o *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(xmrig*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(cgminer*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(bfgminer*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(ethminer*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(minerd*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(npm install -g *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(npm i -g *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(pip install --system*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(pip3 install --system*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(apt*install*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(yum*install*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(brew*install*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(mount *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(umount *)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(> /etc/*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(> /usr/*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(> /bin/*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(> /sys/*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Bash(> /proc/*)","disposition":"Translate policy intent to verified execution rules, scoped permissions or supported hook; validate actual execution paths."},{"pattern":"Read(.env)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(.env.*)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/.env)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/.env.*)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/secrets/**)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/credentials/**)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(~/.ssh/id_*)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(~/.ssh/*.pem)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(~/.ssh/config)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(~/.aws/credentials)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(~/.aws/config)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(~/.config/gcloud/**)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/*.pem)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/*.key)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/*.pfx)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/*.p12)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/private.key)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/privkey.pem)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/id_rsa)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/id_ed25519)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/id_ecdsa)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(**/id_dsa)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(/etc/shadow)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(/etc/sudoers)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."},{"pattern":"Read(/etc/passwd)","disposition":"Translate confidentiality requirement to verified file-read boundary; include shell/MCP coverage assessment."}]},"ignoreTemplate":{"path":"src/targets/claude-code/templates/claudeignore.template","interpretation":"Mixed discovery/noise and sensitivity patterns; never translate all entries mechanically to enforced read denials.","patterns":[".env",".env.*",".env.local",".env.*.local","*.env",".envrc","*.key","*.pem","*.p12","*.pfx","*.cer","*.crt","*.der","id_rsa","id_dsa","id_ecdsa","id_ed25519","*.ppk","*_rsa","*_dsa","*secret*","*password*","*credential*","credentials.json","secrets.json","secrets.yaml","secrets.yml",".aws/credentials",".aws/config",".gcp/credentials.json",".azure/credentials",".npmrc",".pypirc",".gem/credentials","pip.conf","*.sql","*.db","*.sqlite","*.sqlite3","node_modules/","npm-debug.log*","yarn-debug.log*","yarn-error.log*","pnpm-debug.log*",".pnpm-store/","__pycache__/","*.py[cod]","*$py.class",".Python","env/","venv/","ENV/",".venv/","pip-log.txt","pip-delete-this-directory.txt",".eggs/","*.egg-info/","dist/","build/","*.whl","vendor/bundle/",".bundle/","vendor/","go.sum","target/","Cargo.lock","target/","*.class","*.jar","*.war","vendor/","composer.lock","dist/","build/","out/",".next/",".nuxt/",".output/",".vite/",".cache/",".parcel-cache/",".turbo/","*.tsbuildinfo","logs/","*.log","*.tmp","*.temp","*.swp","*.swo","*~",".DS_Store","Thumbs.db","*.bak","*.orig","*.rej",".cache",".git/",".svn/",".hg/",".gitignore",".vscode/",".idea/","*.sublime-*","*.code-workspace",".project",".classpath",".settings/","coverage/",".nyc_output/","htmlcov/",".coverage",".pytest_cache/",".tox/",".DS_Store",".AppleDouble",".LSOverride","Thumbs.db","ehthumbs.db","Desktop.ini","*.mp4","*.avi","*.mov","*.wmv","*.flv","*.mp3","*.wav","*.zip","*.tar.gz","*.rar","*.7z","*.dmg","*.iso","site/","_site/",".docusaurus/",".vuepress/dist/","package-lock.json","yarn.lock","pnpm-lock.yaml","Gemfile.lock","poetry.lock","Pipfile.lock"]},"authority":"https://github.com/dean0x/devflow/issues/333","mdsUpgradeTarget":"0.4.2","mdsUpgradeProbes":{"date":"2026-09-08","current":"0.2.0","target":"0.4.2","oldBackend":"native","newBackend":"native","unmodifiedCommands":[{"command":"bug-analysis.mds","kind":"markdown","beforeBytes":18001,"afterBytes":15037,"equal":false,"literalHelperCalls":3,"warnings":0},{"command":"code-review.mds","kind":"markdown","beforeBytes":20988,"afterBytes":17524,"equal":false,"literalHelperCalls":4,"warnings":0},{"command":"debug.mds","kind":"markdown","beforeBytes":11510,"afterBytes":7881,"equal":false,"literalHelperCalls":2,"warnings":0},{"command":"dynamic-build.mds","kind":"markdown","beforeBytes":64616,"afterBytes":28409,"equal":false,"literalHelperCalls":2,"warnings":0},{"command":"dynamic-plan.mds","kind":"markdown","beforeBytes":24182,"afterBytes":13548,"equal":false,"literalHelperCalls":1,"warnings":0},{"command":"dynamic-profile.mds","kind":"markdown","beforeBytes":12466,"afterBytes":6196,"equal":false,"literalHelperCalls":1,"warnings":0},{"command":"dynamic-tickets.mds","kind":"markdown","beforeBytes":30745,"afterBytes":11364,"equal":false,"literalHelperCalls":1,"warnings":0},{"command":"explore.mds","kind":"markdown","beforeBytes":9430,"afterBytes":5805,"equal":false,"literalHelperCalls":2,"warnings":0},{"command":"implement.mds","kind":"markdown","beforeBytes":25747,"afterBytes":20072,"equal":false,"literalHelperCalls":4,"warnings":0},{"command":"plan.mds","kind":"markdown","beforeBytes":23281,"afterBytes":20311,"equal":false,"literalHelperCalls":3,"warnings":0},{"command":"research.mds","kind":"markdown","beforeBytes":9058,"afterBytes":6311,"equal":false,"literalHelperCalls":2,"warnings":0},{"command":"resolve.mds","kind":"markdown","beforeBytes":37113,"afterBytes":30944,"equal":false,"literalHelperCalls":5,"warnings":0},{"command":"self-review.mds","kind":"markdown","beforeBytes":10637,"afterBytes":5205,"equal":false,"literalHelperCalls":3,"warnings":0}],"results":{"allUnmodifiedCompile":true,"allOutputsDiffer":true,"legacyCallsRemain":33,"newSyntaxPass":true,"legacyEscapesRemainLiteral":true,"rawFrontmatterUnchanged":true,"compileResultNeedsKindNarrowing":true,"targetCompositionPass":true},"targetOutputs":{"claude-code":"Invoke Skill(skill=\"devflow:testing\").\n","codex":"Read the discovered Codex skill testing and its required references.\n"}},"originalLocalInventorySha256":"18a7102709a9990319a85d7b90f847c697c959a9e7ead386a2e1df67da648283"},"arrays":{}}

[dean0x]

Implementation readiness review — 2026-09-08

Assessment: the feature roster is comprehensive at the inspected source baseline; full Codex implementation is not ready to proceed on the current specification alone. The remaining work is to settle specific integration contracts and obtain runtime evidence, rather than discover another broad feature family. The current issue body owns the requirements; this comment preserves the readiness rationale, evidence and proposed validation cases.

The MDS 0.4.2 migration has a concrete target and validation scope and can be developed independently. No runtime Codex parity should be inferred from the successful MDS composition probes.

Rechecked source and drift

Inspected through 23ea357b53bfb38fe4c7ecc48ef8b19bf699abf5. All 258 asset paths remain present, with no added or removed assets against the published inventory. Counts and the 16 role identities remain unchanged. Five assets changed since 08fbdd4: Git role, _wave, debug, plan, and ensure-root-gitignore. Related installer/test changes are also present. The original inventory hashes and compiler measurements remain historical evidence, not hashes of this newer commit.

Carry forward the newer contracts: issue-fetch callers propagate TRACEABILITY: DEGRADED; Git normalizes #-prefixed issue refs and reports dropped batch refs separately from truncation; conventions are committed on the feature branch; ignore maintenance recognizes its own sentinel and preserves user .claudeignore entries/negations. These are existing feature refinements, not additional feature groups.

Contracts that must be concrete before the broad port

Area	Required implementation contract	Proof needed
Hooks	Event normalizer and ordered dispatcher; source ownership/dedupe; supported input/output payloads; trust, timeout, cancellation and failure states	Local/global/plugin sources, trusted/untrusted/changed hooks, prompt/stop/subagent/compaction events, duplicate delivery, malformed/unsupported outputs
Deny lists	Policy categories mapped to real execution and file-access boundaries; no assumed wildcard/prefix equivalence or universal hook interception	Harmless allowed/denied fixtures for direct shell, compound/wrapped commands, patches, later stdin input, symlinks/worktrees and newly created sensitive paths; test MCP separately
Rules	Selected rules composed into the actual discovered instruction chain; preserve user overrides and update timing	Global/project/nested directories, AGENTS.override.md, existing guidance near the size limit, shadowing and enable/disable during an existing session
Subagents	Role identity, initial context, permitted effects, model/effort precedence, capacity/depth and lifecycle	Spawn the intended role; distinguish fresh versus inherited context; run required reviews under a small concurrency limit; exercise report writes, build outputs, Git, cancellation and failure
Skill loading	Resolve an installed, enabled skill and load its full body plus required references before dependent work; translate explicit/implicit activation separately	Workflow → role → domain skill → nested reference; required skill absent/disabled, duplicate names, skill catalog truncation, configured scope/home, updates
Agent loading	Generated role source, valid TOML, discovery, name mapping and invocation form one contract; installation and task labels do not prove role selection	Verify the actual selected role and instructions, then model/permission behavior; role file missing/invalid/conflicting and install/uninstall coexistence
Working memory and charter	Distinct stable orchestration guidance and recalled data; bounded verified delivery; root/child-specific context; restoration and recursion guards	Startup/resume/clear, root and child compaction, spill/overflow, stale branch memory, feature disable, changed charter and detached worker startup

Concrete details needing stronger treatment

1. Context delivery can be partial while the hook succeeds. Devflow reads up to 65,536 bytes of working memory before injection. Codex normally spills additional context over roughly 2,500 tokens to a file and sends a preview. A successful hook or a path to the full text is not evidence that required content reached the role. Choose a bounded delivery budget, explicit required-content reads on spill, and an observable degraded result if loading fails. Critical charter/role rules must not sit only in omitted text. Memory source, hook output limits.

Devflow also silently skips an orchestrator charter exceeding its 4,096-character shell length check. Generated target instructions need a tested size policy and diagnostics. This source limit and the Codex token threshold are different units. Charter loader.

2. Persistent guidance can be installed into a file that is not selected. Codex checks AGENTS.override.md before AGENTS.md, chooses at most one file per directory, and applies a default aggregate 32 KiB instruction budget. Account for the user's existing guidance, not just Devflow's rule size. Explicitly define reload/restart expectations; filesystem update does not establish an already-running session's context changed. Instruction discovery.

3. Skill availability, preload and invocation are distinct. Claude skills: agent metadata and Skill(...) examples need target generation. Codex skills.config controls availability; it is not a documented equivalent of Claude's preload list. Generate a required-skill loading prologue and actual installed-reference resolution for each role/workflow, or use another verified host mechanism. An App Server skill input offers full injection for its own turns, not proof of interactive custom-role preloading. A domain skill omitted from the initial discovery catalog must not silently disappear from a role's mandatory dependencies. Skills, custom roles, App Server skills.

Do not enforce mandatory loading solely by a SubagentStart hook returning continue: false: that field does not stop the subagent from starting. Required-loading failure needs a supported orchestration/role gate and an explicit outcome. SubagentStart.

4. A parent charter must not prevent a leaf agent from working. The existing charter tells the orchestrator never to produce work and says subagents have no conversation context. A Codex child with inherited context could receive parent-only delegation instructions. Specify root versus child context, preserve the child role's assigned work, suppress maintenance launches in worker/child contexts as appropriate, and test compaction on both kinds of thread. Recalled memory and quoted source/issue content must remain distinguishable from the authorized orchestration instructions. Charter source.

Codex documents SessionStart(source="compact") restoration before the next request for root sessions. Do not extend that guarantee to every child/client without evidence. SessionStart lifecycle.

5. Security needs an enforced boundary and a tested failure path. A Claude deny string and a Codex prefix rule are different policies. Include shell/read alternatives, protected Git/config paths, actual permissions inherited by roles, and per-client MCP/network coverage. Unsupported PreToolUse output can mark a hook failed while the tool continues. Distinguish optional maintenance that may fail open from mandatory protection. A prefix-policy match test alone is not proof that every execution path is blocked. Rules, hook decisions, permission scope.

6. Invocation and recursion detection need semantic state. $ARGUMENTS, /devflow:*, Skill(...), and the literal accepted-plan prefix are Claude contracts. The current primer skips reminders only when the prompt starts with /; Codex skills can be invoked with $ or selected implicitly. Define an active-workflow marker and approved-plan artifact handoff so the primer does not redirect an already-running workflow. Preserve user decisions and do not treat a suggested question default as a submitted answer. Primer source.

A bounded compatibility proof

Use a disposable fixture project and supported client/version; no production installation or permission changes. This is a proposed validation task, not work completed in this review:

1. Install one namespaced workflow, two distinct custom roles, one required domain skill/reference, selected rules, and the context/deny adapters. Use harmless fixture-only data.
2. Invoke the workflow, prove correct role selection and complete required skill/reference acquisition, and collect expected artifacts. Use observed events/read traces and behavior, not file existence or an agent's self-report alone.
3. Restore fixture memory and charter on startup/resume/compaction; exercise overflow and root/child isolation. Confirm a child performs its assigned work and a maintenance worker does not recursively start orchestration.
4. Verify representative allowed/denied operations and failure paths without performing destructive actions; show missing/untrusted protection distinctly from active protection.
5. Repeat under local/global scope and the promised platform/client set; uninstall one target while preserving Claude and shared state.

If these checks establish the contracts, finalize the remaining product choices and implementation acceptance criteria. Full implementation can then proceed without depending on unsupported annotations or untested host behavior.

Product choices still open

• Supported clients/platforms and the minimum tested Codex version.
• Direct install/native plugin packaging and namespace/skill visibility behavior.
• Native/full companion HUD experience and terminal dependency policy.
• Role effect boundaries and mandatory versus optional review/QA/skill coverage.
• Background-worker ownership, shared incremental marker equivalence, and standalone preference extraction scope.

Recommended starting scope remains local CLI on macOS/Linux, with devflow init owning lifecycle, explicit required skill loading, shared knowledge plus per-harness runtime provenance, and incomplete mandatory coverage never reported as PASS. These are recommendations until agreed. MDS 0.4.2 upgrade direction and dynamic graph deferral are already recorded decisions.

Retained historical compiler probes and HUD source references

These reference sections were moved from the issue body to keep room for current readiness requirements. The MDS upgrade target remains 0.4.2.

Original 0.2.0 probe baseline

Using Devflow's installed compiler:

Probe	Result
compileFile(file, { vars: { harness: "codex" } }) with an imported helper	Both target outputs compiled successfully
@if harness == "codex"	Selected the correct branch
{harness} in body/inline code	Interpolated in 0.2.0
{{harness}}	mds::syntax in the installed 0.2.0 compiler
Runtime override of a source frontmatter value	Changed body evaluation, left emitted YAML unchanged
{harness} inside a fenced block	Preserved literally
compileFile on current Code agent, React skill, browser reference, compliance skill	mds::not_mds; these are currently ordinary Markdown sources
All 13 existing .mds commands	Compiled successfully with zero warnings

These historical results describe the current 0.2.0 installation. The 0.4.2 probe and migration requirements below establish the new target. Ordinary Markdown still needs explicit treatment, and runtime variables are not a metadata serializer.

Retained HUD research references

These are reference implementations, not selected dependencies or end-to-end validation:

• konnga/codex-hud: closest collector/renderer match, companion cmux/tmux pane; MIT file observed in prior research.
• fwyc0573/codex-hud: incremental rollout parsing and session discovery.
• Oh My Codex: companion pane lifecycle/reconciliation reference.
• anhannin/codex-hud: inside-footer approach carries a Codex source patch.
• brandonwie/codex-hud: secondary standalone/source-patch reference; recheck compatibility/license before reuse.
• Inspected Codex 0.153.0 footer enum and renderer. This pin is historical evidence, not the minimum-version decision.

[dean0x]

Additional memory, learning, and artifact findings — 2026-09-09

This is follow-up evidence for the canonical specification in this issue. Read the September 8 session transcript and the current issue body/readiness evidence before this pass. These findings refine persistence and consumption contracts; they do not reopen the already inventoried tool-name, skill-preload, hook-ordering, rules-budget, model-mapping, or dynamic-runtime questions.

Baseline: Devflow 81a63caa7d31f6da5d987ca59ab66cc494ce0746; local Codex CLI 0.153.4. The audited src/assets files are byte-identical to the prior readiness baseline 23ea357b53bfb38fe4c7ecc48ef8b19bf699abf5. src/core/mds-variants.ts has landed since that baseline. Official Codex documentation was fetched on September 9. No Codex model runs or end-to-end port were executed. Disposable filesystem/Git fixtures exercised current shell contracts without calling a model or changing the working repository.

The roster remains complete at this baseline. The new issues below include existing Devflow defects that coexistence could amplify, plus Codex-specific design gaps. Reproduction status distinguishes those cases.

P01 — Native Codex memories introduce a second recall and learning system

Codex-specific design gap. Codex documents its own optional local memory store, separate generation/use controls, and per-chat /memories controls. Devflow's capture hooks read only .devflow/config.json. Turning native memories off therefore does not turn Devflow capture off, and clearing/retiring a Devflow entry does not remove a copy that Codex's independent recall system may have learned. A later native recollection could reintroduce a superseded fact.

Specify which system owns project decisions, how conflicting recollections are handled, and how the separate controls are explained. Do not automatically disable native memory or pretend its switch already controls Devflow. Also decide whether maintenance codex exec runs retain rollouts or use --ephemeral; ephemeral rollout handling does not, by itself, establish every privacy/retention property.

Evidence: Codex memories, non-interactive execution, Devflow capture gates.

P02 — Moving a chat into a worktree can lose history and reset opt-outs

Codex-specific exposure of existing path semantics; filesystem behavior reproduced. Devflow anchors .devflow to git rev-parse --show-toplevel, meaning each checkout has a distinct local store. Memory, learning, feature config, queues and transient reports are ignored by default; KBs and conventions are tracked. Codex documents that Git-based Handoff does not transfer ignored files unless included through its managed-worktree copy mechanism.

A detached fixture worktree contained the tracked KB but none of the source checkout's memory, decisions, or config.json. The actual queue gate helper then returned memory=true learning=true, despite explicit opt-outs in the original checkout. Worktree continuity must preserve chosen settings and define whether memory/decisions are shared, copied or worktree-local. Copying the whole .devflow tree is not a safe default: live queues, locks and processing claims must not be cloned indiscriminately.

Detached HEAD is a related operational gap: it is Codex's documented default for managed worktrees, but Devflow's discovery excludes detached worktrees, Knowledge skips its commit, and pre-compaction memory bootstrap requires a branch. Establish behavior for review, durable KB persistence, and first compaction before a branch exists. Worktree deletion/restoration also needs an explicit durability policy; this audit did not test which ignored files a Codex snapshot retains.

Evidence: Codex worktrees and Handoff, root resolution, worktree filtering, KB commit guard, bootstrap guard.

P03 — Shared learned content needs applicability, not just event provenance

Design gap confirmed in the data and consumer contracts. Converting shipped MDS/Markdown does not convert already-learned ADRs, pitfalls, KBs or release instructions. A lesson about Claude's Monitor, model names, paths or deny behavior must remain usable in Claude without becoming a universal Codex instruction. A Codex limitation must not cause Learning to retire a still-valid Claude decision as contradicted.

The observation/ledger/index/consumer path has no defined harness/client applicability contract. Adding a field only to the log is insufficient: toLedgerRow projects a whitelist of fields. Define scope for shared versus host-specific knowledge, preserve it through rendering and selection, and define safe handling of legacy unscoped entries. Keep historical citations distinct from instructions to execute now.

Evidence: observation schema, ledger projection, retirement criteria.

P04 — Learning queue claims are not exclusive, and a new claim can already look stale

Existing defect; command semantics reproduced. mv pending processing atomically renames a path, but it does not guarantee one owner while producers can recreate pending. Reproduced interleaving: two agents both observe no processing file; A claims batch A; capture creates batch B; B executes its already-selected mv. B succeeds and replaces A's processing file with batch B. Both agents can believe they own the same path. Ledger locks do not cover the agents' direct observation edits.

Also reproduced: claiming a queue last modified one hour ago preserves that one-hour mtime. The Learning agent touches a normal claim only at the detection-to-curation boundary, so the 900-second stale test can immediately classify a newly active agent as crashed. A single boundary heartbeat also cannot guarantee ownership through a long pause.

Require an exclusive claim operation, ownership identity checked before writes/deletion, and a renewable lease or equivalent liveness contract. Stale recovery must not steal a live batch. This is below the already-recorded event-deduplication requirement: deduplicated events still do not make consumption exclusive.

Evidence: Learning claim protocol, launch stale check. Existing learning-agent tests assert the presence of the mv and heartbeat instructions; they do not prove the concurrent protocol.

P05 — Crash recovery can count the same evidence again

Existing replay exposure; source analysis, no LLM replay test. Learning updates observations and the ledger before deleting the claim as its final act. If interrupted after a reinforcement but before deletion, the next run receives the same evidence. The instructions say to increment observations while deduplicating the evidence strings. There is no processed-event/batch acknowledgement linking the saved observation changes to the consumed input.

assign-anchor's guard against assigning an already-anchored observation is useful, but does not make reinforcement, curation, or citation accounting idempotent. Add replay-safe observation updates and recoverable acknowledgements so one conversation cannot accumulate apparent recurrence through retries. Test interruption after each durable write and before acknowledgement, including denied final deletion.

Evidence: reinforcement, final deletion, anchor guards.

P06 — Event identity must survive synthesis, not stop at capture

Existing consumer defect; actual pairing loop reproduced. The memory formatter pairs an assistant row with the most recent buffered user row. Feeding user A, user B, assistant A produces an apparent user B → assistant A exchange. Even if the Codex normalizer adds session/turn IDs, the current extraction and synthesis loop reads only role/content and would discard those IDs.

Preserve root/thread/turn/worktree identity through grouping, selection and rendered evidence. Specify synthetic-versus-human prompt origin too: Codex documents that a Stop continuation reason becomes a new prompt acting as a user prompt. It must not automatically become evidence of a user's architectural preference. The last_assistant_message field itself is already available in Codex; the gap is consumer semantics and evidence attribution, not absence of that field.

Evidence: memory extraction and pairing, Codex Stop semantics.

P07 — End-of-turn capture leaves active work and applied decisions under-observed

Existing coverage gap, important for Codex's longer turns and delegated workflows. capture-turn consumes only the latest assistant message at Stop. pre-compact-memory saves Git state and a copy of the existing working-memory file; it does not synthesize the active turn. Thus a long investigation can compact or be interrupted after discoveries/tool actions but before those discoveries reach Devflow memory. Merely wiring PreCompact does not establish full current-work preservation.

Citation accounting has the same boundary: apply-decisions permits citations in reasoning, inline comments and structured reports, but the usage scanner receives only the final assistant text. Decisions actually used in a child report can remain at zero cites if the parent concludes with a brief summary. Curation uses zero cites as one retirement signal. Conversely, scanning injected recalls or Learning's own summaries indiscriminately would create self-reinforcement.

Define what active-turn evidence is preserved and when; record applied anchor IDs from owned role results/artifacts, with dedupe and source eligibility. Do not collect private reasoning merely to count application. Codex Interrupt has a short hook timeout and no documented last_assistant_message field, so it cannot be treated as a renamed Stop callback.

Evidence: assistant capture, citation scan invocation, pre-compact snapshot, permitted citation locations, Codex Interrupt.

P08 — The learning corpus already needs a bounded retrieval design

Measured current data; runtime capacity remains client/model dependent. In the local project, decisions-log.jsonl is 801,640 bytes across only 109 rows; decisions.md is 109,936 bytes; pitfalls.md is 378,113 bytes. The three requested inputs total 1,289,689 bytes before queued turns, usage data, role instructions and tool overhead. The largest KB is 85,005 bytes.

Learning asks to read the full log for dedup, and the KB loader concatenates full selected KBs. A small row count or a successful shell read is not proof of complete model-visible content. Tool-output truncation and the role context window require separate handling.

Preserve full-fidelity capture while defining bounded retrieval, paging and completion checks for data inputs. Incomplete dedup evidence must not authorize new duplicate entries or retirement. This extends R5/R7's skill/context delivery concern to the retained data corpus; it is not a request to restore the deliberately removed per-turn capture truncation.

Evidence: Learning input requirements, KB concatenation. Measurements are local runtime-state sizes, not published corpus contents.

P09 — Memory validation can report success for an invalid artifact

Existing defect; actual validation/finalization function reproduced. The save check accepts any nonempty file whose first line begins <!-- memory-head:. A fixture containing only <!-- memory-head: garbage --> passed, replaced memory, deleted the processing batch and created .last-refresh-ok.

The Codex runner must produce a defined artifact, not just exit successfully. Validate the complete stamp, expected source revision, required sections and bounded structure before acknowledgement. Preserve the prior file and pending batch on invalid output. Codex's --output-last-message saves a final response; a workflow that keeps a separate file-writing prompt must not assume that final response is the memory document. Choose either model-authored document output persisted by plumbing, or verified scoped file writes.

Evidence: validation and acknowledgement, Codex output modes.

P10 — Non-ancestor Git history can be labeled “synced”

Existing defect; current session-start hook reproduced with only logging/bootstrap stubbed. The loader counts commits only when the memory SHA is an ancestor of current HEAD. Otherwise the count remains zero, and zero means “synced.” In a temporary repository, memory stamped at commit B was injected as synced after the same branch was rewound to ancestor A. A rebase/diverged or missing memory commit can enter the same misleading state; a branch-name comparison does not detect a same-name rewrite.

Introduce an explicit divergent/unknown-revision state. Equal SHA, ancestor drift, non-ancestor history, missing objects and detached HEAD are different cases. Preserve the snapshot as historical context without presenting it as verified current state.

Evidence: ancestry check, synced classification.

P11 — Knowledge writes can lose entries, then hide the surviving KB files

Existing protocol gap; source analysis. Two Knowledge agents independently read-modify-write the shared index without a lock or version check. Writing each file atomically does not make a two-file update transactional or prevent stale read-modify-write replacement. If one index entry is lost, the loader only falls back to frontmatter when the index is absent or empty. A nonempty incomplete index can therefore hide a valid KNOWLEDGE.md indefinitely.

There is also a preservation gap: the automatic write-back call does not supply EXISTING_KB, while the agent explicitly promises to preserve manual content when that input is provided. The authoring protocol should require reading the current target before refresh, regardless of whether the caller supplied a snapshot.

Define serialized or conflict-detecting KB/index writes, reconciliation of incomplete indexes, and preservation of existing manual content. Require detectable success of the owned Git commit separately from local file creation. Do not equate natural-language “write both atomically” with an actual storage guarantee.

Evidence: direct writes, conditional refresh preservation, fallback gate, write-back inputs.

P12 — Shared artifact filenames can collide before marker policy matters

Existing naming collision exposed by coexistence; source analysis. Review/research/analysis directories use timestamps only to the minute plus branch/topic slug. Two harness runs for the same branch/topic within that minute target the same focus and summary files. Sequential implementation handoffs are scoped only by branch slug, so overlapping runs can overwrite or delete one another's handoff.

G11 already covers incremental-marker provenance. This is a separate pre-marker problem: the actual evidence files can be mixed or overwritten. Assign stable run IDs and make explicit/latest-report selection, handoff ownership and cleanup use those IDs. Preserve cross-harness readability and legacy report discovery through the agreed artifact schema.

Evidence: artifact naming, handoff filename and deletion.

P13 — The Knowledge agent's literal commit command fails

Existing defect; exact command reproduced in a disposable Git repository. The Knowledge agent prescribes:

git -C "{worktree}" commit --only -- .devflow/features/index.md .devflow/features/{slug}/KNOWLEDGE.md -m "docs(knowledge): ..."

-- ends Git option parsing, so -m and the message become pathspecs. The fixture failed with pathspec '-m' did not match any file(s) known to git and the same error for the message. Moving -m and its argument before --, while preserving the same two explicit paths, committed successfully.

Knowledge treats commit failure as non-blocking and reports the KB itself as created/refreshed. Following the literal instruction therefore leaves locally written knowledge without the commit required for sharing; a model might repair the command itself, but correctness must not depend on that. Fix the shared command example and add an executable owned-path commit fixture for both targets. This is a Git instruction defect, not a Codex permissions limitation, and should be corrected before translating the command.

Evidence: exact commit instruction, non-blocking failure rule.

Validation performed and next proof cases

Reproduced seven concrete observations in disposable fixtures: old mtime retained by a new Learning claim; two successful claims with processing-file replacement; cross-session memory mispairing; ignored state/opt-outs absent in a detached worktree; invalid memory accepted with queue deletion; incorrect synced classification after a same-branch history rewind; and the literal KB commit failing while corrected argument ordering succeeds. The claim and pairing probes execute the prescribed shell operations/current formatter; they are not LLM-agent behavior tests. The worktree probe uses ordinary Git, not the Codex Handoff UI.

Add these cases beneath R1–R7, including crash-after-write replay, live lease renewal, native-memory control combinations, worktree handoff with disabled features, first compaction on detached HEAD, complete data acquisition, report-only citation use, concurrent KB writes with a partial index, and two runs sharing a branch and timestamp minute.

Two additional product choices are needed: the relationship between Devflow and native Codex memory controls/authority, and the durability/sharing policy for data and opt-outs across managed worktrees. The remaining items are engineering contracts and source fixes, not reasons to reopen the feature roster or the approved MDS/dynamic-runtime decisions.