Authority model

Canonical authority vocabulary and ownership for Conductor. This document is the provisional M0 home for G1. It does not define Notion schemas, MCP request bodies, or corpus packaging. Downstream milestones must not treat it as verified until external M0 review passes.

See Org model, System components, Organization profile, and Context and integration contract.

Principles

1. Every important fact or artifact class has exactly one decision owner, one authoritative store, permitted readers, permitted writers, and a conflict rule.
2. Hector is an escalation authority for ordinary Initiative and workstream state, not a co-owner of that state.
3. Access to a tool does not confer decision authority.
4. Derived indexes and caches cannot override source systems.
5. Conductor plan authorize is the hard gate for ordinary execution; it is never Hector approval for exceptions or policy.
6. The executing agent writes routine Notion state and production evidence; Conductor does not.
7. The reserved MCP operation authorize means only approval of an exact execution plan. Runtime client access uses authenticate and enforce access, never authorize.

MCP operations

These operations are non-overlapping. A tool or response must declare which one it performs.

Operation	Meaning	May change project state?	May change governed policy?
read	Retrieve context, evidence, or metadata from an authoritative or derived source	No	No
validate	Run deterministic checks against known contracts and return findings	No	No
authorize	Approve or refuse an exact versioned execution plan within delegated policy	No (emits authorization or findings only)	No
complete	Verify authorization-bound execution evidence and an external state-writeback receipt	No (verification record only)	No
propose	Submit an experience, improvement candidate, or governed policy proposal	No	No (proposal only; activation requires governance)

Rules:

• validate accelerates review; it is never required before conversational plan authorization.
• authorize does not imply human-approved.
• Routine state writeback is an executing-agent action against the authoritative store. Conductor's complete_authorized_work MCP operation only verifies the authorization-bound external receipt and records feedback; it never performs or repairs that write.
• Client authentication and access-policy enforcement are runtime responsibilities, not MCP authorize.

Approval and execution statuses

These statuses are non-conflatable. A response must not use one label for another meaning.

Status	Meaning	Issued by
validated	Optional deterministic checks passed for the submitted context or plan fragment	Preparation / validation path
authorized	Conductor approved the exact versioned execution plan	Conductor supervisory agent
human-approved	Hector approved an exception, override, policy change, or declared human judgment gate	Hector
executed	The authorized action occurred and required evidence was recorded in authoritative stores	Evidence in Notion and production tools

authorized must never be represented as human-approved. Planning discussion without an authorization ID is not permission to execute.

Authorization architecture

Scope

An authorization binds all of:

• Initiative ID
• Workstream ID
• Exact stage ID
• Exact active_role
• Exact plan or bundle digest
• Corpus version
• Context version
• Scope and conditions
• Authorization ID and issuance time

One authorization covers one workstream stage and one active role. It does not grant future stages or other roles.

Invalidation

Authorization is invalid when any of the following change materially:

• Initiative or workstream identity
• Stage or active role
• Plan or bundle digest
• Corpus version used for the pack
• Context version (Initiative, workstream, or material evidence snapshot)

The requesting agent must return to Conductor for a new review. Conductor does not silently re-authorize.

Escalation

Escalate to Hector (human-approved required) when:

• Policy change, exception, or override is required
• A declared human judgment gate is hit
• Evidence required by policy is missing and cannot be waived under delegated rules
• Concurrent workstreams conflict in a way Portfolio policy does not resolve

Audit

At architecture level, every plan authorization and escalation must be attributable:

• Who requested (agent/client identity)
• What was authorized or refused (digest, scope, conditions)
• Which corpus and context versions applied
• Whether the result was validated, authorized, refused, or escalated
• Timestamp and authorization ID when issued

Authorization audit records are control-plane artifacts. They are not Initiative Decision/Event state.

Identifier allocation

Stable IDs are minted by the Conductor identity allocator (see system components). Minting an ID is not writing project state. Each row has exactly one minting component, one persisting actor, and one authoritative store after persist.

Identifier	Minted by	Persisted by	Authoritative store after persist
initiative_id	Identity allocator	Executing agent acting for Portfolio Manager	Notion Initiative
workstream_id	Identity allocator	Executing agent for the current line active_role	Notion workstream state
product_id	Identity allocator	Executing agent acting for Product Manager	Notion Product
asset_id	Identity allocator	Executing agent acting for Portfolio Manager	Notion Asset registry
Decision/Event ID	Identity allocator	Executing agent for the owning role of that event class	Notion Decision/Event
Authorization ID	Identity allocator only	Conductor supervisory agent emits the ID inside the authorization record after requesting a mint; the supervisory agent is not a co-allocator	Authorization audit / pack store

Fact and artifact ownership

Each row has exactly one decision owner. Escalation and delegated-writer rules are separate columns, not co-owners.

Fact or artifact class	Decision owner	Escalation	Authoritative store	Permitted readers	Permitted writers	Conflict rule
Initiative outcome, DoD, priority, portfolio status, relationships	Portfolio Manager	Hector for exceptions and judgment gates	Notion Initiative	Conductor (read); roles permitted by privacy class	Executing agent acting for Portfolio Manager	Notion wins over packs, indexes, chat memory, and GitHub
Workstream line, stage, role, status, bindings, evidence, next action	Current active_role	Portfolio Manager for cross-workstream conflicts; Hector for declared judgment gates	Notion workstream state	Conductor (read); roles permitted by privacy class	Executing agent for the current active_role	Notion wins; pack is a snapshot bound to context_version
Product evaluation, scores, gates	Product Manager	Hector for scorecard or gate overrides	Notion Product	Conductor (read); Product roles	Executing agent under Product Manager	Notion Product wins over Initiative free-text duplicates
Asset / estate description	Portfolio Manager	Hector for disputed merge/supersede	Notion Asset registry	Conductor (read); permission-filtered roles	Delegated: humans or agents with Asset write permission; never Conductor compiler	Reviewed Asset record wins over README, index cache, and unreviewed extraction
Software delivery evidence	Engineering Lead	Hector for declared Software judgment gates	GitHub repository	Conductor (read); Software roles	Delegated Software roles via GitHub under Engineering Lead	GitHub wins for source, PRs, checks, releases, deployments
Editorial publication artifacts	Editor-in-Chief	Hector for declared Editorial judgment gates	Editorial production tools / site repo	Conductor (read, privacy-safe); Editorial roles	Delegated Editorial roles under Editor-in-Chief	Editorial store wins; Initiative holds links and summaries only
Services client artifacts	Engagement Manager	Hector for privacy or commercial exceptions	Private client folders	Role-permitted only; Conductor may see privacy-safe metadata	Delegated Services roles under Engagement Manager	Client store wins; never copy secret values into packs or corpus
Operate runtime state and runbooks	Platform Engineer	Hector for declared Operate judgment gates	Runtime tools and runbooks	Conductor (read); Operate roles	Delegated Operate roles under Platform Engineer	Runtime/runbook wins for operational truth
Timed attention	Portfolio Manager	Hector	Calendar	Permitted roles	Executing agent under Portfolio Manager	Calendar is not project state; Notion wins for Initiative status
Proposed plan or document bundle	Requesting agent	—	Versioned proposed-plan store	Conductor (review); requesting agent; audit readers	Requesting agent	Newer plan version supersedes prior drafts; does not grant execution permission; does not own Conductor review output
Conductor review artifacts (questions, findings, refusals, revision requests, escalations before authorization)	Conductor supervisory agent	Hector when escalation content requires human approval	Conductor review / conversation store	Requesting agent; audit readers	Conductor supervisory agent	Review artifacts do not grant execution; superseded by later review turns or by an authorization record
Authorization record / authorized pack	Conductor supervisory agent	Hector when escalation required before issue	Authorization record / pack store	Requesting agent; audit readers	Conductor supervisory agent emits once; immutable after issue	Superseded only by a new authorization for changed scope; invalidation requires re-review
Line-workstream Decision/Event content	Current active_role	Hector for exceptions recorded as human approvals	Notion Decision/Event	Conductor (read); permitted roles	Executing agent for the current active_role	Notion wins; control-plane authorization audit IDs are not Decision/Event records
Portfolio disposition Decision/Event content	Portfolio Manager	Hector for exceptions recorded as human approvals	Notion Decision/Event	Conductor (read); permitted roles	Executing agent acting for Portfolio Manager	Notion wins; distinct from line-workstream events
Completion / writeback record	Current active_role	Portfolio Manager if writeback ownership is disputed	Notion completion and state fields	Conductor (read / verify); permitted roles	Executing agent for the current active_role	Notion completion record wins; Conductor may detect missing/stale writeback but must not silently repair
Experience records	Submitting role	—	Conductor experience store	Permission-filtered Conductor and reviewers	Submitting agent via feedback tools	Experiences do not change corpus
Improvement candidates	Scheduled reviewer (non-binding)	Hector activates policy only through governance	Conductor candidate store	Reviewers; Conductor	Scheduled reviewer creates candidates	Candidates never override corpus; only governed Hector approval activates policy
Corpus units, schemas, templates, compiler configuration	Hector	—	Governed repo assets (corpus/, schemas, templates, config)	Conductor; agents via packs	Proposal path writers; merge only after Hector approval	Approved merged policy wins over proposals, candidates, and generated mirror
Generated documentation mirror	Build pipeline	—	docs/generated/	Humans and agents as descriptive aid	Generator only	Never design authority; handwritten model and approved corpus win
Organization profile values	Hector	—	Organization profile configuration	Conductor runtime	Governed configuration change under Hector	Profile specializes core; cannot silently redefine core semantics
Secret names and provider bindings	Hector	—	Organization profile / adapter configuration	Conductor runtime (config); operators	Governed profile or adapter config change	Names and bindings are configuration references, not secrets
Secret values	Secret provider	—	Secret provider only (e.g. Bitwarden)	Runtime secret resolution with least privilege	Secret-management process for the provider	Values never appear in packs, corpus, state, indexes, or profile docs; missing value is explicit failure
Client authentication events	Platform Engineer (control plane)	Hector for access-policy exceptions	Runtime authN store	Operators	Client identity and authentication component	Control-plane only; not Initiative state
Access-policy enforcement decisions	Platform Engineer (control plane)	Hector for policy exceptions	Runtime access log	Operators	Access-policy enforcement component	Control-plane only; not plan authorize
Plan-authorization audit event content	Conductor supervisory agent	Hector	Authorization audit store	Operators; audit readers	Authorization audit component (content)	Audit evidences Conductor plan decisions; not Notion Decision/Event authority
Authorization-audit retention policy	Platform Engineer	Hector	Runtime / platform retention configuration	Operators	Platform Engineer via governed runtime config	Retention policy does not alter audit-event meaning or Initiative state
Operational observability telemetry	Platform Engineer	—	Observability store	Operators	Operational observability component	Telemetry is not project state

Documentation authority hierarchy

When documents disagree, use this precedence. Do not silently prefer the newest file.

1. Hector-approved behavior-bearing policy — merged governed corpus, schemas, templates, and compiler configuration.
2. Canonical model and authority contracts — this document, org-map-model.md, system-components.md, organization-profile.md, integration-contract.md, tooling-map.md.
3. Organization profile — Hector-specific bindings that specialize core without replacing it.
4. Line and software decision documents — roles-and-tooling.md, software-decisions.md, docs/lines/. Exact stage IDs in org-map-model.md win over drifted line prose until lines are aligned.
5. Generated corpus mirror — docs/generated/; descriptive snapshot only until regenerated from aligned source.
6. Examples and descriptive history — packs, examples, journals; not binding policy.
7. Archived material — archive/; never live authority.

Conflict handling

1. Prefer the higher-precedence source.
2. If two sources at the same precedence conflict, surface an explicit contradiction; do not invent a merge.
3. If a lower-precedence source is clearer but conflicts with a higher one, treat the lower as drift and open a governed change or M2 migration item.
4. Generated and archived matches that repeat superseded concepts (active_line, attending_lines, mandatory GitHub Issues as work contracts) are expected until M2; they are not current design authority.

Downstream use (after external M0 verification)

Until M0 is externally verified, treat this document as provisional remediation. After verification:

• M1 designs Notion/Asset/read-adapter storage and ID persistence using this ownership and allocator table; it does not reopen whether Conductor writes routine state.
• M2 migrates corpus using the core versus organization-profile split in organization-profile.md and the exact stage IDs in org-map-model.md.
• M3 designs MCP contracts using read / validate / authorize / propose and the four statuses above, without reusing authorize for client access control.