---
name: "skill-portfolio-allocation"
type: skill
license: CC BY-NC-SA 4.0
description: 'The allocation decide-step for a portfolio operator — how operator-apps decides across its bets instead of driving one goal to a target. Ranks the portfolio''s bets by leverage, allocates the cycle''s finite fleet capacity across them top-down, and recommends a per-bet disposition (sustain, park, restart, kill, graduate). Composed by operator-apps alongside skill-operating-loop, replacing the loop''s single-goal decide step; not a standalone schedule. Read when running the Apps accelerator loop, or when reasoning about how a portfolio''s fleet capacity is shared. Holds the altitude split — this arbitrates across bets within one portfolio, Atlas arbitrates across operators — and the mandate boundaries: GTD off the commercial axis, os.Claude attention not canon authority, kill and graduate as Owner escalations.'
---

# portfolio-allocation

The decide-step for a **portfolio** operator. A single-outcome operator (BARA, A1, bot.Trader, Mr P) decides the next best actions toward *one* goal; a portfolio operator (`operator-apps`, the accelerator) instead decides how to **share finite fleet capacity across several bets**. This skill is that decide-step: it drops into `skill-operating-loop` in place of its single-goal "decide the next best actions" step, and hands its output back to the same dispatch, mandate-edge and report steps. It never executes work and never re-implements Atlas — it arbitrates *across bets within one portfolio*, where Atlas arbitrates *across operators* (`core-operating-model`, Layer 3).

## Trigger

Run by a portfolio operator inside its operating loop (`task-apps-operator-loop` → `skill-operating-loop`), in place of that loop's single-goal decide step. Requires the portfolio's bets, each bet's goal / KPI / health, and the cycle's available fleet capacity. Not a standalone scheduled job.

## Behaviour

### Pass 0 — Reconcile last cycle's allocation against what actually ran

Before ranking anything, read the previous cycle's allocation from this operator's last status update and the allocation table on the Owner-session agenda, and mark each slice **consumed**, **partially consumed**, or **never started**, from the tickets' own state (`completedAt`, `startedAt`, an open PR). Capacity allocated to a lane that cannot execute is not spent — it is wasted and reported as spent, and the starvation call in Pass 3 is then wrong in both directions: a bet is recorded as fed when it was not, and the capacity it nominally consumed was never available to a bet that could have used it. Feed non-consumption into Pass 2: a bet whose slice never started does not rank as if it had been fed. A slice **never started for two consecutive cycles** is a **capability gap**, not a scheduling accident — name it, and escalate it on the loop's mandate-edge path in Pass 5 with a recommendation (re-route the surface, or park the bet), never re-allocate it a third time. `skill-fleet-dispatch`'s readiness test holds the same un-runnable tickets daily (APP-991) and does not reach this allocator; the Figma write-path gap is one cause (APP-963); this pass is the class. (Worked case: the 2026-08-17 loop allocated APP-122 and APP-508 to Pixel on the Figma surface and the Forge lane to os.Claude; the Forge slice was consumed within 24 hours, both Pixel slices were untouched five days later, and only a re-read of the same ticket IDs stopped a third identical allocation — APP-1049.)

### Pass 1 — Resolve membership, then read each bet's standing

Resolve the portfolio's membership from the **tracker** — the vertical's team and its live projects in Linear (`convention-linear`) — not from a list named in prose. Membership is a rule applied to live state, never a list. A bet is a project in the vertical's team that is linked to the vertical's initiative, less the standing named exceptions the operator profile records (for Apps, `operator-apps` *Mandate*). Projects that share a bet-level initiative are read as one bet. Each bet's **active or inactive** standing is read from its project status on the same run. In Progress or Planned is active. Hold, Backlog, Paused, Completed or Canceled is inactive, and an inactive bet gets no allocation, no date escalation and no cycle proposal, except in the status-inconsistent case below. Read the status **name**, not its type: Hold is type `planned` in this workspace (`convention-linear`), so a read by type counts a parked bet as live. Canon holds the rule and Linear holds the state. So a park, restart, kill or graduate ruling is applied to the project in Linear and logged in the decision log, and is never written back into canon as a list (Owner, 2026-09-21 — APP-1578). The first run under this rule names every bet whose standing it changes from the last report. Any project in the team that the rule neither includes nor excludes is a **membership-drift** item, and so is one linked to no initiative of the vertical's that is not a named exception: name it explicitly. Because membership drift is a **goal-set change**, surface each drift item to the Owner on the loop's mandate-edge escalation — the escalation shape already exists and ran by hand in APP-882; resolving from the tracker makes it fire by design rather than by chance. Without the diff a new project created in the vertical's team is invisible to the operating loop until someone re-reads the mandate, and a missed drift also suppresses the Owner decision it should have triggered, so the diff is not optional (APP-887).

**And the count is not the diff — Pass 1 publishes the resolved membership itself, every project named by identifier, so the next run diffs membership against membership.** A bare figure records how many bets the rule resolved and nothing whatever about which, so a project-set delta is unattributable in principle. **The direction of the error is what earns the clause here**: a bet that has departed the portfolio and a bet that was never in it read identically from two bare counts, and a departure is exactly the goal-set change this pass exists to escalate. So the run's report names, by **Linear project identifier** (the `P-APP-16` form, never the display name alone): the in-portfolio projects, the standing named exceptions, and each drift item. `APP-2336`'s rule — a count is published with the identifiers it counted — was written for a ticket or queue count in a stand-up entry and applies unchanged to a project-set count, as `APP-2674` and `APP-2858` applied it to two further counts. The **weekly cadence is the aggravating term**: this loop fires once a week, so the window in which a delta is still attributable has closed by the next report, and a count published bare is therefore unattributable *in principle* rather than merely unattributed. (Worked case, **observed**: the Apps initiative status update of 2026-11-11T12:27:35Z states "22 projects in the Apps team; 21 linked to the Apps initiative" and does publish the set — "In-portfolio projects, all 17", four standing exceptions and drift item `a1.Platform`, reconciling to 22 — so the remedy has been exercised once by hand, and that drift item is already on the Owner's lane as `APP-2535`. The update one week earlier, 2026-11-04T12:28:28Z, states "23 projects … 22 linked" and publishes no list at all, so the single project-set change between the two reports cannot be attributed from the reports themselves. One further read trap, named because it reads as a pass: `list_projects` returns **trashed** projects as ordinary live rows unless `trashed` is selected in `fields`, so the membership read selects it — `APP-3049`.)

**A project the rule *includes* is a bet by that act — its first appearance is not drift, and not a goal-set change.** The sentence above makes drift a goal-set change, and drift is defined narrowly: a project the rule *neither includes nor excludes*. A project the rule **does** include — in the vertical's team, linked to the vertical's initiative, not a named exception — is settled by the act of linking it, and needs no separate Owner ruling to become a bet. Name it in the run's report as a new bet with its standing, and allocate to it. Escalate only where (a) the rule cannot place it, (b) a named exception is in question, or (c) the run **recommends a non-default placement** — that recommendation is the Owner's call, the membership is not. Without this the two readings compose into an Urgent Owner-lane question the operator already had the answer to: app.DS-Quality was raised on 2026-09-22 as *is this a sixth Apps bet*, sat two weeks, and was closed on 2026-10-06 with the Owner pointing out the question was already answered by the live-resolution rule the ticket itself cited (APP-1639, APP-2118; same shape previously in APP-882, APP-995 and APP-1325, each of which was a genuine exception call and so correctly escalated).

**A `Backlog` status denies nothing on its own — where the project demonstrably holds ready work, Pass 1 allocates on that demonstrated readiness and flags the status.** The clause above gates allocation on a field no loop may write: `skill-operating-loop` (*Guardrails*, *Tracker hygiene inside the vertical*) puts project status outside the operator's hygiene grant in either direction, and `convention-project-status` rules the correction a major-level surface that `skill-plan`'s weekly pass **surfaces and proposes, never auto-writes**. Read together the two compose into a standing denial of capacity that neither states. So **a stale status is a lag, not a decision**, and reading it as a deliberate denial costs a ready bet its entire allocation every cycle for as long as the proposal is unruled — and this operator is the only party that notices, because the gate fires inside this pass. Where a bet's project status reads **`Backlog`** and the project holds at least one ticket in a started or unstarted state whose relations were read on this run and carry **no open** `blocked-by`, report the bet as **status-inconsistent** and allocate to it on that readiness, at its Pass 2 rank. That read is the whole of the test and nothing softer stands in for it: the qualifying ticket IDs are named in the run's report, read live from the board with the same per-ticket relation read Pass 3 already requires before a slice lands, never from a document and never from prose. **`Backlog` is the one inactive status that records no decision.** Hold, Paused, Completed and Canceled each record an act — Pass 4's park, or a terminal call — and stand as the deliberate denial they are, however much live work the project still holds; `convention-project-status` excludes `Hold` from its own stale-status check by name for exactly this reason and routes a parked project with a live tail to its own minor-level finding (APP-2265). The status correction is proposed to the Owner in parallel, as the major-level surface it is, and **the operator does not write the field** — no grant follows from this clause in either direction, and the companion clause in `skill-operating-loop`'s hygiene guardrail says so from the other side, naming this pass so that the pair cannot re-compose into the deadlock. (Worked case: `app.DS-Quality`, a bet by the Owner's 2026-10-06 membership ruling (APP-1639), carried status **Backlog** on 2026-10-14 while its hosting decision APP-2247 had been Done since 2026-10-09 and it held seven refined build tickets filed 2026-10-09 — APP-2246 and APP-2248–APP-2253 — of which APP-2248 was checked directly: its blocker cleared, its acceptance criteria and definition of done both present, buildable that day. `app.Foundry` was held the same way. Both were named as hygiene at the W40, W41 and W42 boundaries and no write followed, a fourth consecutive week in which two ready bets received nothing. APP-2362, folding APP-2045; ruled in the canon-decisions session of 2026-10-20 as reported on APP-2362 — the provenance **unverified**, the connector stamping every comment on this workspace as the Owner's and no transcript being readable from the refine surface, which is the disclosure form of APP-2279.)

For every resolved bet, read its goal, KPI movement, health, in-flight work, and blockers from its own sources. A bet with **no outcome goal** is named as a strategy gap to close, not scored as on-track. Read the real numbers, never assumed ones.

The principle — resolve scope from the tracker, never from a list in prose — recurs across artefacts; the Owner has already ruled it for `task-daily-report` (APP-876 decision 2), so the read pattern and the escalate-the-diff behaviour are phrased to match. `skill-operating-loop` step 1 carries the same exposure at lower volume for a single-outcome operator; note it there, but it is not fixed by this edit.

### Pass 2 — Rank the bets by leverage

Rank the bets by expected outcome movement per unit of fleet capacity this cycle, weighted by strategic priority (the Priority Board / latest `skill-plan` focus) and by genuine near-term commitments — a live launch, or a target date that is a real commitment (never one sitting behind a Hold, `convention-linear`). Name the ranking and the one-line reason for each position.

### Pass 3 — Allocate finite fleet capacity

Allocate the cycle's **available** fleet capacity (one Forge per repo, the connector fleet's bandwidth) top-down across the ranked bets until capacity is spent. Name explicitly which bets are **starved** this cycle rather than pretending everything fits — finite capacity is the whole point of the exercise. **Allocate only to a ticket with no open** `blocked-by`**.** Read each candidate's relations before it takes a slice. A ticket behind an open blocker cannot consume capacity this cycle, so allocating to it books Pass 0's never-started slice in advance. A bet whose ready set is entirely blocked is reported as **starved by precondition**, naming the blocker and its lane, and the capacity passes down the ranking. (Worked case: the 2026-09-14 loop gave Luna's Forge slice to APP-60, APP-61 and APP-63. Each had carried `blocked-by` APP-1034, a `human` credential ticket, since 2026-09-13. None started, and the report guessed "may gate on Vercel" when the relation was on the ticket — APP-1571, 2026-09-21.) **A precondition that is not on the board is still a precondition — resolve the repos, connectors, credentials and hosts a candidate's deliverable needs, and test them against what the delivery surface actually carries, before the ticket takes a slice.** The relation rule above reads the board, and a candidate can need something the board never records: a repo that does not exist, a connector the delivery session does not carry, a credential, a host. None of those is a relation, a state, a label or a priority, so the relation read passes, the heading check passes, Pass 1's project-status test passes, skill-build-ticket's claim gate never fires because the ticket is never claimed, and Pass 0 learns of it a cycle later by non-consumption — every field a reader checks agrees. So resolve each candidate's preconditions from the ticket or from its target repo, and run them against the surface: `routine-delivery-loop` already holds the rule that connector scope is an eligibility condition checked before the claim, covering every connector class the deliverable needs rather than only GitHub's repo list (APP-652), and `convention-github`'s *Repos in scope* table is the named set it is tested against. What belongs here is the **test and the pointer, never a copy of the roster** — a scope list restated in this file drifts from the two artefacts that own it, and drifts in the direction that reads as a pass. A bet whose ready set fails that test is reported as **starved by precondition** on the same footing as one behind an open blocker, naming the missing repo or connector and whose act provisions it, and the capacity passes down the ranking. The check is stated in this artefact as well as in those two because a rule stated in one artefact never reaches the others, and this is the artefact that buckets the allocation decision (`task-daily-report`, *A ruled decision is not an open ask*, APP-1644). (Worked case: APP-2248 and APP-2249 were promoted to Todo under `F0-RGE` on 2026-10-21 — app.DS-Quality's first-ever capacity — and seven days later were still Todo, unclaimed, with no `stateHistory` movement after that promotion, **observed**. app.Triage's six remaining `F0-RGE` Todo tickets were held the same way after the bet shipped 17 tickets the week before; APP-2248's only `blocked-by` had been cleared on 2026-10-25 and APP-2249 carried none, so the relation read above passed on both — **reported**. The preconditions themselves sit off the board and are unreadable from this surface, so they are the delivery loop's **report**: `assoc-one/a1-de` is not in the delivery session's connector scope, and no `ds-quality` repo exists. Pass 0 forbids re-allocating a twice-never-started slice, so the honest disposition the week after would have been **park** — for two refined, unblocked bets whose only defect was a configuration line. Escalated as APP-2728, with `blocks` relations onto all eight held tickets, which is what put the precondition on the board. APP-2362 named this shape for project status and APP-1571 for an unread `blocked-by`, each reached from a different side; APP-652 is the delivery-level antecedent whose fix never reached this allocator — APP-2729, 2026-10-28.) **GTD** is allocated on personal-infrastructure grounds, never the commercial axis; **os.Claude** is allocated *attention* only, never authority over canon (which still moves Pulse-proposes → Owner-saves).

### Pass 4 — Per-bet disposition

For each bet, recommend exactly one:

- **Sustain** — keep allocating; it is earning its capacity.
- **Park** — stop allocating and move the project to Hold; revisit later. (Operator's call within mandate.)
- **Restart** — un-park a Held bet back into allocation. (Operator's call.)
- **Kill** — retire the bet. A **goal-set change → Owner escalation**, never unilateral. GTD is exempt from kill-for-no-revenue.
- **Graduate** — the bet has earned its own operator; a peer vertical leaves the portfolio. An **Owner call**, case by case, no written bar (`core-operating-model`, *Graduation*).

### Pass 5 — Hand back to the loop

Return the ranked allocation and the per-bet dispositions as the decide-step's output. `skill-operating-loop` runs its dispatch (via Relay), mandate-edge check, autonomous-proceed and report steps on it unchanged. **Kill** and **graduate** recommendations ride the loop's mandate-edge escalation to the Owner; park / restart / sustain proceed within mandate. Membership-drift items raised in Pass 1 ride the same escalation.

## Guardrails

- **Allocation, not execution.** Proposes how capacity is shared; the fleet executes via Relay. Never runs the work itself.
- **Membership comes from the tracker, not prose.** Resolve the portfolio's bets, and each one's active standing, from the vertical's Linear team, initiative and project status, less the named exceptions. Escalate whatever the rule cannot place. Canon holds no list of bets to diff against (APP-887, APP-1578).
- **Finite capacity is the point.** Never allocate beyond the cycle's real fleet capacity; name what is starved.
- **The altitude split.** Arbitrates across bets within one portfolio; Atlas arbitrates across operators. Never re-implement Atlas.
- **GTD off the commercial axis; os.Claude attention, not authority.** Never judge GTD on revenue; never grant the operator canon authority over os.Claude.
- **Kill and graduate are Owner escalations**, never unilateral; park / restart are the operator's within mandate.
- **Read real KPI / health, no fabrication** (`convention-ticket`).

## Setup

Composed by `operator-apps` alongside `skill-operating-loop` — it is the loop's decide-step for a portfolio, not a separate schedule. Reusable if a second portfolio operator ever appears. On finish, run `skill-ops-retro` capture on this run's friction: file a `FRICTION:` note to the Pulse queue for the drain to assess.

## Tone

Calm, precise, sentence case, British spelling, no exclamation marks, outcome before adjective. (cos.tov.)
