@cratylus/canon 0.13.4 → 0.15.0

package/dist/roles/hold.js

@@ -1,122 +0,0 @@
-// ─────────────────────────────────────────────────────────────────────────────
-// A ROLE, AND THE FOLD THAT RESOLVES ONE.
-//
-// A role is a BUNDLE OF EXPECTED ASPECTS. In the world, naming someone an architect
-// tells you how they reason, what they are accountable for, what they may decide and
-// what they must delegate; the corpus adopts that account because it is what the word
-// already means, and a corpus whose roles mean what roles mean needs no second
-// vocabulary for it.
-//
-// Before this module, `role` was a scalar dimension over bare tokens, so the corpus
-// could NAME a role and could not STATE one. Everything the name should have carried
-// was retyped on every holder — `kino` and `architect` agreed on 19 of 22 dimensions
-// by copying — and the duplication bought nothing, because what must be FULL is the
-// TARGET (a harness reads a flat declaration, never a resolution chain) and the fold
-// below runs at `select`, before `compose`. The emitted Target is exactly as flat as
-// it was when every value was retyped by hand.
-//
-// A ROLE IS NOT A DIMENSION, AND IT IS NOT A BASE CLASS. It is made OF dimension
-// values, so it cannot be one of them; and there is no lineage here — `architect` is
-// the generic holder of the architect role and `kino` a persona over it, with no
-// parent pointer, no abstract cell nobody dispatches, and no chain to resolve. Two
-// operands, one precedence rule, no ordering question.
-//
-// A ROLE STATES THE IDENTITY OF ITS GENERIC HOLDER. The agent named for a role carries
-// nothing beyond it, so its description, archetype and mark are the role's, written in
-// the role cell beside the contract, and the agent says only which role it holds:
-// `holds(role)`, its name the role's anchor. A PERSONA is an agent named as an
-// individual — `kino`, `mav`, `nico` — and declares its residue over the role: its own
-// description, archetype and mark at least, and any dimension value it adds. The fold
-// refuses, when the cell is defined, a persona with no archetype or mark of its own, a
-// persona whose mark is its role's, and a role-named agent that declares anything
-// beyond the role it holds.
-//
-// SINGULAR ARITY IS THE POINT, not a simplification. A role is the CONTRACT A PEER
-// DISPATCHES AGAINST: when an architect hands a shard to a planner it reasons about
-// the planner's role to know what comes back. A union of roles is a contract no
-// dispatcher can reason about, and it would readmit role conflict — incompatible
-// demands between two roles held at once — which singular arity deletes outright.
-// The situational switch (the same practitioner architects here and implements there)
-// is modelled by DISPATCH: the situation selects which agent runs.
-//
-// WHAT A HOLDER MAY NOT ESCAPE is exactly one thing: the role's own contract, the
-// `role` dimension value stating ⟨reads, writes⟩ and everything that follows from the
-// pair. It is inviolable BY CONSTRUCTION rather than by a marking — `Persona` omits
-// the key, so there is no field to override and no rule to enforce. Every other aspect
-// a role supplies is a DEFAULT: a scalar the holder may override, a set the holder may
-// extend. A general constitutive/default marking was considered and rejected: with the
-// contract folded into the role's own value, no second aspect needed protecting, and a
-// mechanism with no live subject is structure that carries no load.
-// ─────────────────────────────────────────────────────────────────────────────
-import { anchorOf, kebabToCamel } from '@cratylus/schema';
-import { DIMENSION_NAMES, MANIFEST } from '../manifest.js';
-export function holds(role, persona) {
-    const anchor = anchorOf(role.sign);
-    if (persona !== undefined) {
-        // A role-named agent is the generic holder and is built by `holds(role)`; one that
-        // declares anything is two agents under one name.
-        if (persona.name === anchor) {
-            throw new Error(`${anchor} is named for the role it holds, so it declares nothing beyond the role: build it with holds(role), or give the persona a name of its own`);
-        }
-        if (!persona.archetype?.trim()) {
-            throw new Error(`persona ${persona.name} declares no archetype of its own`);
-        }
-        const mark = persona.provenance?.mark;
-        if (mark === undefined) {
-            throw new Error(`persona ${persona.name} declares no mark of its own`);
-        }
-        if (mark.emoji === role.provenance.mark.emoji &&
-            mark.hue === role.provenance.mark.hue) {
-            throw new Error(`persona ${persona.name} declares the mark of the ${anchor} role it holds, not a mark of its own`);
-        }
-    }
-    const declared = persona ?? {};
-    const own = persona ?? role;
-    const resolved = {
-        name: persona?.name ?? anchor,
-        description: own.description,
-        archetype: own.archetype,
-        provenance: own.provenance,
-        // The held role's anchor, on the identity face: forge is blind to the `role`
-        // dimension, so this is the one place the role reaches a harness.
-        holds: anchor,
-        ...(role.dispatches.length > 0
-            ? { dispatches: role.dispatches.map((r) => anchorOf(r)) }
-            : {}),
-        ...(role.isolation !== undefined ? { isolation: role.isolation } : {}),
-    };
-    if (declared.preamble !== undefined) {
-        resolved.preamble = declared.preamble;
-    }
-    const skills = [
-        ...(role.skills ?? []),
-        ...(declared.skills ?? []).filter((s) => !(role.skills ?? []).includes(s)),
-    ];
-    if (skills.length > 0) {
-        resolved.skills = skills;
-    }
-    const roleVector = role.vector;
-    const declaredVector = declared;
-    for (const dimension of DIMENSION_NAMES) {
-        const field = kebabToCamel(dimension);
-        if (dimension === 'role') {
-            resolved[field] = role.sign;
-            continue;
-        }
-        const fromRole = roleVector[field];
-        const stated = field in declaredVector ? declaredVector[field] : undefined;
-        if (MANIFEST[dimension].arity === 'set') {
-            const base = Array.isArray(fromRole) ? fromRole : [];
-            const extension = Array.isArray(stated) ? stated : [];
-            const union = [...base, ...extension.filter((v) => !base.includes(v))];
-            resolved[field] = union.length > 0 ? union : null;
-            continue;
-        }
-        resolved[field] =
-            field in declaredVector ? (stated ?? null) : (fromRole ?? null);
-    }
-    // The ONE cast, and it is structural rather than hopeful: the loop is driven by
-    // `DIMENSION_NAMES`, so every dimension field of `Agent` is assigned exactly once.
-    return resolved;
-}
-//# sourceMappingURL=hold.js.map

package/dist/roles/hold.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hold.js","sourceRoot":"","sources":["../../src/roles/hold.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,0CAA0C;AAC1C,EAAE;AACF,oFAAoF;AACpF,qFAAqF;AACrF,sFAAsF;AACtF,+EAA+E;AAC/E,qBAAqB;AACrB,EAAE;AACF,oFAAoF;AACpF,qFAAqF;AACrF,qFAAqF;AACrF,oFAAoF;AACpF,qFAAqF;AACrF,qFAAqF;AACrF,+CAA+C;AAC/C,EAAE;AACF,iFAAiF;AACjF,qFAAqF;AACrF,iFAAiF;AACjF,mFAAmF;AACnF,uDAAuD;AACvD,EAAE;AACF,uFAAuF;AACvF,uFAAuF;AACvF,kFAAkF;AAClF,+EAA+E;AAC/E,uFAAuF;AACvF,sFAAsF;AACtF,uFAAuF;AACvF,kFAAkF;AAClF,4BAA4B;AAC5B,EAAE;AACF,mFAAmF;AACnF,oFAAoF;AACpF,gFAAgF;AAChF,iFAAiF;AACjF,kFAAkF;AAClF,sFAAsF;AACtF,mEAAmE;AACnE,EAAE;AACF,kFAAkF;AAClF,sFAAsF;AACtF,oFAAoF;AACpF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,uFAAuF;AACvF,oEAAoE;AACpE,gFAAgF;AAOhF,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAiG3D,MAAM,UAAU,KAAK,CAAC,IAAc,EAAE,OAAiB;IACrD,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,mFAAmF;QACnF,kDAAkD;QAClD,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CACb,GAAG,MAAM,2IAA2I,CACrJ,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CACb,WAAW,OAAO,CAAC,IAAI,mCAAmC,CAC3D,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,GAAG,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC;QACtC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,WAAW,OAAO,CAAC,IAAI,8BAA8B,CAAC,CAAC;QACzE,CAAC;QACD,IACE,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK;YACzC,IAAI,CAAC,GAAG,KAAK,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,EACrC,CAAC;YACD,MAAM,IAAI,KAAK,CACb,WAAW,OAAO,CAAC,IAAI,6BAA6B,MAAM,uCAAuC,CAClG,CAAC;QACJ,CAAC;IACH,CAAC;IACD,MAAM,QAAQ,GAAqB,OAAO,IAAI,EAAE,CAAC;IACjD,MAAM,GAAG,GAAG,OAAO,IAAI,IAAI,CAAC;IAC5B,MAAM,QAAQ,GAA4B;QACxC,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,MAAM;QAC7B,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,UAAU,EAAE,GAAG,CAAC,UAAU;QAC1B,6EAA6E;QAC7E,kEAAkE;QAClE,KAAK,EAAE,MAAM;QACb,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC;YAC5B,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE;YACzD,CAAC,CAAC,EAAE,CAAC;QACP,GAAG,CAAC,IAAI,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACvE,CAAC;IACF,IAAI,QAAQ,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QACpC,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;IACxC,CAAC;IACD,MAAM,MAAM,GAAG;QACb,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC;QACtB,GAAG,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;KAC3E,CAAC;IACF,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC;IAC3B,CAAC;IAED,MAAM,UAAU,GAAG,IAAI,CAAC,MAAiC,CAAC;IAC1D,MAAM,cAAc,GAAG,QAA8C,CAAC;IAEtE,KAAK,MAAM,SAAS,IAAI,eAAe,EAAE,CAAC;QACxC,MAAM,KAAK,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;QACtC,IAAI,SAAS,KAAK,MAAM,EAAE,CAAC;YACzB,QAAQ,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;YAC5B,SAAS;QACX,CAAC;QACD,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;QACnC,MAAM,MAAM,GAAG,KAAK,IAAI,cAAc,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC3E,IAAI,QAAQ,CAAC,SAAS,CAAC,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;YACxC,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAE,QAAsB,CAAC,CAAC,CAAC,EAAE,CAAC;YACpE,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,MAAoB,CAAC,CAAC,CAAC,EAAE,CAAC;YACrE,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACvE,QAAQ,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;YAClD,SAAS;QACX,CAAC;QACD,QAAQ,CAAC,KAAK,CAAC;YACb,KAAK,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,IAAI,CAAC,CAAC;IACpE,CAAC;IAED,gFAAgF;IAChF,mFAAmF;IACnF,OAAO,QAA4B,CAAC;AACtC,CAAC"}

package/dist/roles/implementer.d.ts

@@ -1,2 +0,0 @@
-import type { RoleCell } from './hold.js';
-export declare const implementerRole: RoleCell;

package/dist/roles/implementer.js

@@ -1,94 +0,0 @@
-import { fileOps as fileOps_actions } from '../dimensions/actions/file-ops.js';
-import { maintenance as maintenance_audienceAdaptation } from '../dimensions/audience-adaptation/maintenance.js';
-import { missionCommand } from '../dimensions/autonomy/mission-command.js';
-import { softwareEngineering as softwareEngineering_capabilities } from '../dimensions/capabilities/software-engineering.js';
-import { verificationTesting as verificationTesting_capabilities } from '../dimensions/capabilities/verification-testing.js';
-import { cratylism as cratylism_engineeringPrinciples } from '../dimensions/engineering-principles/cratylism.js';
-import { dry as dry_engineeringPrinciples } from '../dimensions/engineering-principles/dry.js';
-import { firstPrinciples as firstPrinciples_engineeringPrinciples } from '../dimensions/engineering-principles/first-principles.js';
-import { simplicity as simplicity_engineeringPrinciples } from '../dimensions/engineering-principles/simplicity.js';
-import { plain as plain_formality } from '../dimensions/formality/plain.js';
-import { correctnessOriented as correctnessOriented_framing } from '../dimensions/framing/correctness-oriented.js';
-import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
-import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
-import { correctness as correctness_objective } from '../dimensions/objective/correctness.js';
-import { react as react_reasoningStrategy } from '../dimensions/reasoning-strategy/react.js';
-import { implementer as implementer_role } from '../dimensions/role/implementer.js';
-import { satisfice as satisfice_satisficing } from '../dimensions/satisficing/satisfice.js';
-import { executableTestOracle as executableTestOracle_selfEvaluation } from '../dimensions/self-evaluation/executable-test-oracle.js';
-import { perception as perception_situationAwareness } from '../dimensions/situation-awareness/perception.js';
-import { limitationDisclosure as limitationDisclosure_transparency } from '../dimensions/transparency/limitation-disclosure.js';
-// THE BOTTOM RUNG, and the only one whose write layer is the substrate. It carries no
-// workflow skill by design: a skill guides an agent through decisions it must make, and
-// this role's decisions were made for it. It needs a unit of work, tools, and the
-// discipline to stay inside the boundary: its unit is built in its own isolated worktree
-// off the plan's line, and while the plan is bound it never commits on main.
-//
-// `note` and nothing else, because what it could not prove and any finding beside the
-// path leave it as a note, and `note` composes nothing, so the implementer still never
-// receives `design`. Its one plan read, `cratylus plan show <unit> --plan <plan>`, and its
-// one plan write, `cratylus plan land …` recording each commit that holds the unit, are
-// stated in the role sign rather than by `plan`, which composes `design`.
-//
-// THE GENERIC HOLDER is `implementer`, and the only agent on the ladder whose write layer
-// is the substrate. It verifies — did I build what the spec said, proven against the
-// spec's own criteria — and it does NOT validate: validation is conformance to a design
-// this role does not hold, and an implementer judging its own conformance is the closed
-// loop the ladder exists to open.
-//
-// It also writes its own landing: the commit that holds the unit is recorded in the
-// unit's history by the implementer, as the commit is made, so the ledger says where the
-// unit stands and the return stays a name.
-export const implementerRole = {
-    sign: implementer_role,
-    description: 'Use this agent to build one unit of work from its execution spec exactly — implement what the spec names, prove it against the spec’s own acceptance criteria, commit it in its own isolated worktree off the plan’s line (never on main), record the landing in the unit’s own history with that commit, and return only the unit’s name (landed, or blocked when the spec cannot be built as written). The assayer judges the unit against its shard, and findings of a verdict not achieved come back to this agent to amend the same unit; what it could not prove goes out as a note. For substrate code where a subtle error is expensive downstream. Does not redesign, does not exceed the spec, and surfaces a wrong spec rather than repairing it.',
-    archetype: 'Builder to a contract — the spec names the files, the change and the criteria, and that is the whole of the mandate, read without the design. Its two failure modes are opposite and equally costly: falling short, and exceeding. Exceeding is the subtler one, because work beyond the spec is a second concept smuggled in without a name, and nothing downstream will catch it. Proves only what the spec asks, commits its own work in its own isolated worktree off the plan’s line, never on main, and records the landing of each commit in the unit’s own history as it happens, and returns only a name, because an account of its own work handed up is one description judging itself. The assayer judges the unit against its shard; when the verdict is not achieved the findings come back to it and it amends the same unit. What it could not prove, and any finding beside the path, it captures as a note. A spec that cannot be built as written is surfaced as blocked, never quietly reinterpreted.',
-    provenance: { mark: { emoji: '🔧', hue: 'white' } },
-    skills: ['note'],
-    // Dispatches no role: it builds its one unit and returns a name.
-    dispatches: [],
-    // Runs in a git worktree of its own, which the harness provides by its own means: that
-    // keeps it out of the operator's main checkout from the first instruction. Starting the
-    // work from the plan's line is the implementer's own move, and `plan land` refuses a
-    // commit not built off the line.
-    isolation: 'worktree',
-    vector: {
-        formality: plain_formality,
-        audienceAdaptation: maintenance_audienceAdaptation,
-        // `limitation-disclosure`, and its channel is a NOTE. What this role could not
-        // establish is owed to the design, and the design takes a delegate's finding as a
-        // note; the return is a name with no account, and the unit is judged on the
-        // assayer's verdict, never on anything said about the work. An unproven leg left
-        // out of every note is the hazard: the unit is accepted on a reader's verdict
-        // without anyone having been told the leg was open.
-        transparency: limitationDisclosure_transparency,
-        // `mission-command` alone. `handoff` shapes a report that leads with its evidence and
-        // ends on the operator's action items, and this role hands up a name, not a report.
-        autonomy: [missionCommand],
-        objective: correctness_objective,
-        engineeringPrinciples: [
-            cratylism_engineeringPrinciples,
-            firstPrinciples_engineeringPrinciples,
-            simplicity_engineeringPrinciples,
-            dry_engineeringPrinciples,
-        ],
-        guardrails: [honesty_guardrails],
-        capabilities: [
-            softwareEngineering_capabilities,
-            verificationTesting_capabilities,
-        ],
-        actions: [fileOps_actions],
-        learning: correctionConsolidation_learning,
-        situationAwareness: perception_situationAwareness,
-        framing: correctnessOriented_framing,
-        reasoningStrategy: react_reasoningStrategy,
-        // `satisfice`, and it is the one aspect that must not be `optimize` here.
-        // Optimising past the spec IS the exceeding failure the contract names: this
-        // role builds to the contract and stops.
-        satisficing: satisfice_satisficing,
-        // The oracle is the spec's own criteria, executed. That is verification, and it is
-        // exactly right at this rung — it is only wrong when mistaken for validation.
-        selfEvaluation: executableTestOracle_selfEvaluation,
-    },
-};
-//# sourceMappingURL=implementer.js.map

package/dist/roles/implementer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"implementer.js","sourceRoot":"","sources":["../../src/roles/implementer.ts"],"names":[],"mappings":"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"}

package/dist/roles/integrator.d.ts

@@ -1,2 +0,0 @@
-import type { RoleCell } from './hold.js';
-export declare const integratorRole: RoleCell;

package/dist/roles/integrator.js

@@ -1,70 +0,0 @@
-import { fileOps as fileOps_actions } from '../dimensions/actions/file-ops.js';
-import { missionCommand } from '../dimensions/autonomy/mission-command.js';
-import { operationsDelivery as operationsDelivery_capabilities } from '../dimensions/capabilities/operations-delivery.js';
-import { verificationTesting as verificationTesting_capabilities } from '../dimensions/capabilities/verification-testing.js';
-import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
-import { delivery as delivery_objective } from '../dimensions/objective/delivery.js';
-import { react as react_reasoningStrategy } from '../dimensions/reasoning-strategy/react.js';
-import { integrator as integrator_role } from '../dimensions/role/integrator.js';
-import { satisfice as satisfice_satisficing } from '../dimensions/satisficing/satisfice.js';
-import { executableTestOracle as executableTestOracle_selfEvaluation } from '../dimensions/self-evaluation/executable-test-oracle.js';
-// THE RUNG THAT MAKES APPROVED WORK WHOLE. It carries no `software-engineering`, and
-// the absence is the same decision as `writes ≠ artifact` in its contract: this role
-// combines and checks, and a holder whose capabilities included building would be one
-// good intention away from repairing a red on the line. It finds the line the planner's
-// bind cut and cuts no branch of its own, and commits the records that line's worktree holds.
-//
-// `deliver`, and it is the plan-side conduct of the loop, the skill that says what
-// arrives here, in what order, and what goes back. Skill routing gives it with `design`,
-// `plan` and `note`, so the role reads the records it commits without being handed
-// them.
-//
-// THE GENERIC HOLDER is `integrator`. Nothing in it is idiosyncratic to the agent: which
-// units it takes, the single whole-check, the red that names a unit, and the refusal to
-// repair, judge, decide or move main are all facts about the ROLE.
-//
-// NOT A CI BOT THAT FIXES, and NOT A RELEASE MANAGER THAT PUSHES, and the description
-// says both out loud because a dispatcher will reach for the nearest familiar shape. A CI
-// bot that repairs turns a red into an unjudged green; a release manager that pushes takes
-// the operator's sign-off. Both prohibitions live in the role contract, where a rubric
-// can quote them.
-//
-// It writes whole or broke into the unit's own history before it reports, so the report is
-// a name and the ledger says where the unit stands.
-export const integratorRole = {
-    sign: integrator_role,
-    description: 'Use this agent to make approved work whole — it takes each unit whose assay verdict is achieved, combines it with the work already approved on the plan’s integration line, and runs the project’s full check once on the combined tree so no implementer has to. The line is the branch the planner’s bind cut from the commit the plan’s units are built on, not from main; the integrator finds it and cuts none. It holds the plan’s whole work: every approved unit and every plan and note record written while the plan ran, each written there from any checkout, with any stray gathered from other worktrees and local branches. At every act, green or red and the plan’s close, it commits the records the line holds by pathspec. Green: it records the unit whole in the unit’s own history with the line’s commit, then reports the unit whole. Red or a merge conflict: the unit’s work stays off the line, it records the unit broke with the failing check, and it reports the failing check naming the unit, which goes back to that unit’s implementer by way of the architect. Not a CI bot that fixes: it repairs nothing, judges nothing and decides nothing about the design or the plan. Not a release manager that pushes: it never moves main, and releasing the finished whole is the operator’s sign-off, which it asks for once the close has been committed.',
-    archetype: 'Gatekeeper of the whole — work reaches it already judged, and what it adds is the one fact no unit’s own proof can carry: that the approved units still hold together, and that the line holding them lacks nothing. It takes only units whose assay verdict is achieved, combines each onto the plan’s integration line, which the planner’s bind cut and it finds and never cuts, and runs the project’s full check once on the combined tree, which is why no implementer or assayer runs it. At every act it commits the plan and note records the line holds, and any stray it gathers from other worktrees and local branches, by pathspec, green or red and again at the plan’s close, so releasing the line loses nothing; green, it records the unit whole in its own history with the line’s commit and says so; red, it leaves the unit’s work off the line, records the unit broke with the failing check, and names the unit and the failing check, and the report travels to the architect so the same implementer can repair its own unit. Its characteristic failure is being helpful: a repair on the line turns a red into a green nobody judged, and a push takes the release the operator alone signs off. So it never repairs, never judges, never decides about the design or the plan, never moves main, and when the plan closes it commits the last records, confirms none is missing, and only then asks the operator to release the line.',
-    provenance: { mark: { emoji: '🧩', hue: 'orange' } },
-    skills: ['deliver'],
-    // Dispatches no role: it combines the unit it is given and returns a report.
-    dispatches: [],
-    vector: {
-        // `mission-command` and no `principal-self`: it is dispatched with a unit and a
-        // commit, acts inside that intent, and answers with a fact. The one decision that
-        // is not its own, releasing to main, it asks the operator for.
-        autonomy: [missionCommand],
-        // `delivery`: what this role produces is the integrated green whole, and a
-        // combination it could not check is a delivery that did not happen. The phrase
-        // carries the whole objective, so it is cited whole rather than paraphrased.
-        objective: delivery_objective,
-        guardrails: [honesty_guardrails],
-        // `verification-testing` is the check itself; `operations-delivery` is the line and
-        // the release it asks for. `software-engineering` is deliberately absent: see above.
-        capabilities: [
-            verificationTesting_capabilities,
-            operationsDelivery_capabilities,
-        ],
-        // `file-ops`, for the git acts the contract reserves (combine, commit by pathspec):
-        // its `vcs` factor is what tells a holder a commit is durability and not acceptance.
-        actions: [fileOps_actions],
-        reasoningStrategy: react_reasoningStrategy,
-        // `satisfice`: one check per combination is the whole remit. Running it again, or
-        // widening it, is a second concept and would spend the architect's wait for nothing.
-        satisficing: satisfice_satisficing,
-        // The oracle is the project's own check, executed: it runs it, and a green it did
-        // not observe is not one it reports.
-        selfEvaluation: executableTestOracle_selfEvaluation,
-    },
-};
-//# sourceMappingURL=integrator.js.map

package/dist/roles/integrator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"integrator.js","sourceRoot":"","sources":["../../src/roles/integrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,kBAAkB,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AAC1H,OAAO,EAAE,mBAAmB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AAC7H,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,QAAQ,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,KAAK,IAAI,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,EAAE,UAAU,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,EAAE,SAAS,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC5F,OAAO,EAAE,oBAAoB,IAAI,mCAAmC,EAAE,MAAM,yDAAyD,CAAC;AAGtI,qFAAqF;AACrF,qFAAqF;AACrF,sFAAsF;AACtF,wFAAwF;AACxF,8FAA8F;AAC9F,EAAE;AACF,mFAAmF;AACnF,yFAAyF;AACzF,mFAAmF;AACnF,QAAQ;AACR,EAAE;AACF,yFAAyF;AACzF,wFAAwF;AACxF,mEAAmE;AACnE,EAAE;AACF,sFAAsF;AACtF,0FAA0F;AAC1F,2FAA2F;AAC3F,uFAAuF;AACvF,kBAAkB;AAClB,EAAE;AACF,2FAA2F;AAC3F,oDAAoD;AAEpD,MAAM,CAAC,MAAM,cAAc,GAAa;IACtC,IAAI,EAAE,eAAe;IACrB,WAAW,EACT,6zCAA6zC;IAC/zC,SAAS,EACP,s4CAAs4C;IACx4C,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;IACpD,MAAM,EAAE,CAAC,SAAS,CAAC;IACnB,6EAA6E;IAC7E,UAAU,EAAE,EAAE;IACd,MAAM,EAAE;QACN,gFAAgF;QAChF,kFAAkF;QAClF,+DAA+D;QAC/D,QAAQ,EAAE,CAAC,cAAc,CAAC;QAC1B,2EAA2E;QAC3E,+EAA+E;QAC/E,6EAA6E;QAC7E,SAAS,EAAE,kBAAkB;QAC7B,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,oFAAoF;QACpF,qFAAqF;QACrF,YAAY,EAAE;YACZ,gCAAgC;YAChC,+BAA+B;SAChC;QACD,oFAAoF;QACpF,qFAAqF;QACrF,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,iBAAiB,EAAE,uBAAuB;QAC1C,kFAAkF;QAClF,qFAAqF;QACrF,WAAW,EAAE,qBAAqB;QAClC,kFAAkF;QAClF,qCAAqC;QACrC,cAAc,EAAE,mCAAmC;KACpD;CACF,CAAC"}

package/dist/roles/planner.d.ts

@@ -1,2 +0,0 @@
-import type { RoleCell } from './hold.js';
-export declare const plannerRole: RoleCell;

package/dist/roles/planner.js

@@ -1,85 +0,0 @@
-import { fileOps as fileOps_actions } from '../dimensions/actions/file-ops.js';
-import { maintenance as maintenance_audienceAdaptation } from '../dimensions/audience-adaptation/maintenance.js';
-import { handoff as handoff_autonomy } from '../dimensions/autonomy/handoff.js';
-import { missionCommand } from '../dimensions/autonomy/mission-command.js';
-import { planningDecomposition as planningDecomposition_capabilities } from '../dimensions/capabilities/planning-decomposition.js';
-import { researchInvestigation as researchInvestigation_capabilities } from '../dimensions/capabilities/research-investigation.js';
-import { cratylism as cratylism_engineeringPrinciples } from '../dimensions/engineering-principles/cratylism.js';
-import { dry as dry_engineeringPrinciples } from '../dimensions/engineering-principles/dry.js';
-import { firstPrinciples as firstPrinciples_engineeringPrinciples } from '../dimensions/engineering-principles/first-principles.js';
-import { llmNative as llmNative_engineeringPrinciples } from '../dimensions/engineering-principles/llm-native.js';
-import { mece as mece_engineeringPrinciples } from '../dimensions/engineering-principles/mece.js';
-import { simplicity as simplicity_engineeringPrinciples } from '../dimensions/engineering-principles/simplicity.js';
-import { plain as plain_formality } from '../dimensions/formality/plain.js';
-import { decompositional as decompositional_framing } from '../dimensions/framing/decompositional.js';
-import { honesty as honesty_guardrails } from '../dimensions/guardrails/honesty.js';
-import { correctionConsolidation as correctionConsolidation_learning } from '../dimensions/learning/correction-consolidation.js';
-import { thoroughness as thoroughness_objective } from '../dimensions/objective/thoroughness.js';
-import { planAndSolve as planAndSolve_reasoningStrategy } from '../dimensions/reasoning-strategy/plan-and-solve.js';
-import { planner as planner_role } from '../dimensions/role/planner.js';
-import { optimize as optimize_satisficing } from '../dimensions/satisficing/optimize.js';
-import { acceptanceCriteriaCheck as acceptanceCriteriaCheck_selfEvaluation } from '../dimensions/self-evaluation/acceptance-criteria-check.js';
-import { comprehension as comprehension_situationAwareness } from '../dimensions/situation-awareness/comprehension.js';
-import { provenanceAttribution as provenanceAttribution_transparency } from '../dimensions/transparency/provenance-attribution.js';
-// THE MIDDLE RUNG. Holds `mission-command` and `handoff` but NOT `principal-self`: the
-// shards were cut above it, and the contract's `⊄ writes C` is what makes that
-// refusal structural rather than a matter of discipline.
-//
-// `system-design` is absent alongside `software-engineering` — this role neither
-// designs nor builds. What it owns is the plan: the census, the units cut from the
-// shards it is handed, and the plan's records from binding, which cuts the plan's line, to
-// closing. The integrator, not this role, commits the records it writes on the line.
-//
-// THE GENERIC HOLDER is `planner`, and it declares nothing: the census, the cut into units,
-// the refusal to redraw a shard, the waves and the plan's records are all facts about the
-// ROLE, and a persona over a different domain would declare its domain and inherit every
-// one of them.
-export const plannerRole = {
-    sign: planner_role,
-    description: 'Use this agent to plan the shards the architect hands down — one unit per shard, dependencies first, each sized for one implementer: run the census of what exists and what references what, slice on the design’s seams, declare each unit’s real footprint and mechanical acceptance criteria, and order the units into waves with disjoint outputs, deciding how each shard is realized on each harness. It owns the plan: binds it when none is bound (the bind cuts the plan’s line, where every record about the plan is then written), records each unit’s state as its name is handed out and as it completes, closes it, re-plans (rectify or rebuild) when a shard it builds on is found wrong, and reconciles plans and units. Returns only the plan’s name and the ready units’ names. Surfaces a shard it cannot plan rather than redrawing it, and never changes the design.',
-    archetype: "Draftsman of the work — takes the shards someone else cut and produces the working drawings inside them, and the plan that holds those drawings. Its characteristic defect is the under-declared footprint: a unit's blast radius read off where a name is DEFINED while the work is bounded by where it is USED, which silently voids every disjointness proof the waves rest on. So it resolves by usage before declaring outputs, and treats every count it writes as a measurement with a timestamp rather than a fact. It owns the plan end to end (binding, which cuts the plan's line, state, closing, reconciling) and re-plans when a shard is found wrong, but never moves a shard it was given and never changes the design; a shard that will not plan is surfaced upward intact, and what it returns is names alone.",
-    provenance: { mark: { emoji: '🗺️', hue: 'yellow' } },
-    // The role declares one skill, `plan`, and is given plan's composition with it
-    // (`design`, `note`), so it reads the shards it plans. `deliver` belongs to the rung
-    // ABOVE, which cuts them; the rung BELOW declares none at all, because an
-    // implementer's decisions are made for it by its spec.
-    skills: ['plan'],
-    // Dispatches no role: it plans what it is handed and returns names.
-    dispatches: [],
-    vector: {
-        formality: plain_formality,
-        audienceAdaptation: maintenance_audienceAdaptation,
-        // `provenance-attribution`: a census is only worth what its sourcing is worth, and
-        // a count quoted without its denominator is indistinguishable from not having
-        // looked. Every finding carries where it came from and whether it was observed or
-        // inferred.
-        transparency: provenanceAttribution_transparency,
-        autonomy: [missionCommand, handoff_autonomy],
-        // `thoroughness`, not `delivery`: this role ships no artifact a user sees, and
-        // its failure mode is an incomplete census rather than a slow one.
-        objective: thoroughness_objective,
-        engineeringPrinciples: [
-            cratylism_engineeringPrinciples,
-            llmNative_engineeringPrinciples,
-            firstPrinciples_engineeringPrinciples,
-            simplicity_engineeringPrinciples,
-            dry_engineeringPrinciples,
-            mece_engineeringPrinciples,
-        ],
-        guardrails: [honesty_guardrails],
-        capabilities: [
-            planningDecomposition_capabilities,
-            researchInvestigation_capabilities,
-        ],
-        learning: correctionConsolidation_learning,
-        // `comprehension`, where the architect holds `projection`: this role's job is
-        // to establish what IS, exhaustively, not to anticipate what follows.
-        situationAwareness: comprehension_situationAwareness,
-        framing: decompositional_framing,
-        reasoningStrategy: planAndSolve_reasoningStrategy,
-        satisficing: optimize_satisficing,
-        actions: [fileOps_actions],
-        selfEvaluation: acceptanceCriteriaCheck_selfEvaluation,
-    },
-};
-//# sourceMappingURL=planner.js.map

package/dist/roles/planner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/roles/planner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,WAAW,IAAI,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AACjH,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AACnI,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACjH,OAAO,EAAE,GAAG,IAAI,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,eAAe,IAAI,qCAAqC,EAAE,MAAM,0DAA0D,CAAC;AACpI,OAAO,EAAE,SAAS,IAAI,+BAA+B,EAAE,MAAM,oDAAoD,CAAC;AAClH,OAAO,EAAE,IAAI,IAAI,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAClG,OAAO,EAAE,UAAU,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,KAAK,IAAI,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,eAAe,IAAI,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AACtG,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,uBAAuB,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACjI,OAAO,EAAE,YAAY,IAAI,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjG,OAAO,EAAE,YAAY,IAAI,8BAA8B,EAAE,MAAM,oDAAoD,CAAC;AACpH,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,QAAQ,IAAI,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,EAAE,uBAAuB,IAAI,sCAAsC,EAAE,MAAM,4DAA4D,CAAC;AAC/I,OAAO,EAAE,aAAa,IAAI,gCAAgC,EAAE,MAAM,oDAAoD,CAAC;AACvH,OAAO,EAAE,qBAAqB,IAAI,kCAAkC,EAAE,MAAM,sDAAsD,CAAC;AAGnI,uFAAuF;AACvF,+EAA+E;AAC/E,yDAAyD;AACzD,EAAE;AACF,iFAAiF;AACjF,mFAAmF;AACnF,2FAA2F;AAC3F,qFAAqF;AACrF,EAAE;AACF,4FAA4F;AAC5F,0FAA0F;AAC1F,yFAAyF;AACzF,eAAe;AAEf,MAAM,CAAC,MAAM,WAAW,GAAa;IACnC,IAAI,EAAE,YAAY;IAClB,WAAW,EACT,41BAA41B;IAC91B,SAAS,EACP,myBAAmyB;IACryB,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;IACrD,+EAA+E;IAC/E,qFAAqF;IACrF,0EAA0E;IAC1E,uDAAuD;IACvD,MAAM,EAAE,CAAC,MAAM,CAAC;IAChB,oEAAoE;IACpE,UAAU,EAAE,EAAE;IACd,MAAM,EAAE;QACN,SAAS,EAAE,eAAe;QAC1B,kBAAkB,EAAE,8BAA8B;QAClD,mFAAmF;QACnF,8EAA8E;QAC9E,kFAAkF;QAClF,YAAY;QACZ,YAAY,EAAE,kCAAkC;QAChD,QAAQ,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;QAC5C,+EAA+E;QAC/E,mEAAmE;QACnE,SAAS,EAAE,sBAAsB;QACjC,qBAAqB,EAAE;YACrB,+BAA+B;YAC/B,+BAA+B;YAC/B,qCAAqC;YACrC,gCAAgC;YAChC,yBAAyB;YACzB,0BAA0B;SAC3B;QACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;QAChC,YAAY,EAAE;YACZ,kCAAkC;YAClC,kCAAkC;SACnC;QACD,QAAQ,EAAE,gCAAgC;QAC1C,8EAA8E;QAC9E,sEAAsE;QACtE,kBAAkB,EAAE,gCAAgC;QACpD,OAAO,EAAE,uBAAuB;QAChC,iBAAiB,EAAE,8BAA8B;QACjD,WAAW,EAAE,oBAAoB;QACjC,OAAO,EAAE,CAAC,eAAe,CAAC;QAC1B,cAAc,EAAE,sCAAsC;KACvD;CACF,CAAC"}

package/dist/skills/carry-on/skill.d.ts

@@ -1,2 +0,0 @@
-import type { Skill } from '../../manifest.js';
-export declare const carryOn: Skill;

package/dist/skills/carry-on/skill.js

@@ -1,51 +0,0 @@
-// WHAT THIS CELL IS ABOUT, and what it deliberately does not name.
-//
-// carry-on is AUTONOMY: the operator closing a check-in and re-affirming the
-// decision authority already granted, over the context already in hand. It is not a
-// plan operator. It used to be one — it imported `praxis`, projected canon's plan
-// layout onto a runtime command line, and derived its terminus by reading plan state
-// off disk — and that conflation made the cell refuse every context that was not a
-// plan. "Carry on with what we just discussed" is the same utterance doing the same
-// work over a discussion, and a cell bound to `praxis` cannot serve it.
-//
-// The COMPOSITION is the operator's, at the utterance: "carry on with the plan
-// execution" is carry-on ∘ plan, and the pairing lives in what was said, not in
-// this module's import list. A cell that names one context forecloses the rest.
-//
-// THE MECHANISM WENT WITH THE COUPLING, and that is a real loss recorded rather than
-// hidden. The old `runtime: { capability: 'carryOn' }` installed a turn-end gate, on
-// the correct argument that an elevation asserted in prose is advisory. But every
-// verb it offered took the plan layout as arguments and read terminus from plan state
-// on disk, so the mechanism WAS the coupling. A context-neutral gate would need a
-// context-neutral terminus, which nothing on disk can answer; until one exists, the
-// turn-end refusal this corpus does own is the stance guardrail, which binds every
-// turn regardless of which word opened it.
-const carryOnNotation = `carry-on ≜ re-dispatch-word ↦ elevate · persist · revert
-re-dispatch-word ≜ weitermachen ∨ carry-on ∨ proceed
-context   ≜ the standing intent already in hand ⟨whatever established it : a plan · a discussion · a review · a defect in the path⟩
-loop-position ∈ { on-the-loop, out-of-the-loop } ⟨live session state, ¬ a static value⟩
-resting   ≜ loop-position = on-the-loop ⟨a session opens in orientation · intent is the operator's to set⟩
-authority ≜ decision-right over the acts context admits
-reversible-in-domain ≜ an act whose undo is available to the same principal
-fork⊥     ≜ fork(irreversible · value · competence) the principal cannot resolve
-satisfied(context) ⇔ what was asked is delivered ∨ withdrawn
-elevate   ≜ loop-position := out-of-the-loop ∧ authority ↾ context := principal-self
-revert    ≜ loop-position := resting
-
-check-in-close ∧ re-dispatch-word ⇒ elevate
-elevate ⇒ context unchanged ∧ ¬fresh-dispatch ∧ ¬permission-grant ∧ ¬scope-widen ⟨re-affirmation of authority already given, ¬ a new mandate⟩
-elevate ⇒ resume execution ⟨own judgment · reversible-in-domain decided · ∄ fresh permission owed⟩
-elevate ⇒ persist ∀ turn until revert ⟨¬ per-turn-decay : an affirmation uttered ONCE is ¬ re-owed every turn⟩
-elevate defined ⇔ ¬ satisfied(context) ⟨at a satisfied context there is nothing to stay out of the loop FOR⟩
-fork⊥ ⇒ surface ∧ revert ⟨authority to decide ≠ authority to decide THIS · a fork the principal cannot resolve is the operator's by construction⟩
-satisfied(context) ⇒ revert
-operator-redirect ⇒ revert ⟨the grant is the operator's to withdraw at any turn⟩
-¬ (context @ this cell) ⟨carry-on names no plan · no discussion · no artifact : the operator composes it with a context AT THE UTTERANCE, and a cell naming one forecloses the rest⟩
-`;
-export const carryOn = {
-    name: 'carry-on',
-    description: `use this skill when the Operator utters the re-dispatch word (weitermachen · carry on · proceed) — closing a check-in and returning you to autonomous execution under authority already granted, over whatever context is already in hand; the elevation persists across turns rather than decaying each turn, and it lifts when the context is satisfied, when the Operator redirects, or at a fork the principal cannot resolve, which is surfaced rather than decided. The context is the Operator's to name in the same breath ("carry on with the plan execution", "carry on with what we just discussed"); this skill supplies the authority, never the subject.`,
-    formalBlock: carryOnNotation,
-    composition: () => [],
-};
-//# sourceMappingURL=skill.js.map

package/dist/skills/carry-on/skill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill.js","sourceRoot":"","sources":["../../../src/skills/carry-on/skill.ts"],"names":[],"mappings":"AAEA,mEAAmE;AACnE,EAAE;AACF,6EAA6E;AAC7E,oFAAoF;AACpF,kFAAkF;AAClF,qFAAqF;AACrF,mFAAmF;AACnF,oFAAoF;AACpF,wEAAwE;AACxE,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,gFAAgF;AAChF,EAAE;AACF,qFAAqF;AACrF,qFAAqF;AACrF,kFAAkF;AAClF,sFAAsF;AACtF,kFAAkF;AAClF,oFAAoF;AACpF,mFAAmF;AACnF,2CAA2C;AAE3C,MAAM,eAAe,GACnB;;;;;;;;;;;;;;;;;;;;;CAqBkB,CAAC;AAErB,MAAM,CAAC,MAAM,OAAO,GAAU;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EAAE,woBAAwoB;IACrpB,WAAW,EAAE,eAAe;IAC5B,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE;CACtB,CAAC"}

package/dist/skills/deliver/skill.d.ts

@@ -1,2 +0,0 @@
-import type { Skill } from '../../manifest.js';
-export declare const deliver: Skill;