yarramate 0.7.0 → 0.8.0

package/catalogues/core-enrichment.yaml

@@ -1,15 +1,18 @@
 format: yarramate/question-catalogue/v1
 id: core-enrichment
-version: "0.3"
+version: "0.4"
 profile: yarramate/core@0.1
 presentation:
   title: Core enrichment interview
   description: >-
-    The guided design path: motivation, business, and application waves plus
-    cross-cutting hygiene (technology and implementation follow in a later
-    version). Each question states the decision its answer changes; a
-    question that cannot is deleted, not softened. Adequacy is enforced by
-    linkage depth and attestation, never by reading words.
+    The guided design path: motivation, business, application, technology,
+    and implementation waves plus cross-cutting hygiene. Each question
+    states the decision its answer changes; a question that cannot is
+    deleted, not softened. Adequacy is enforced by linkage depth and
+    attestation, never by reading words. Versioning is additive within a
+    major version: every question records the catalogue version it arrived
+    in (ADR 0063), and a completed interview honestly reopens when the
+    path deepens.
 
 waves:
   - id: motivation
@@ -23,6 +26,16 @@ waves:
     description: >-
       How declared services are realized, performed, and fed with
       information.
+  - id: technology
+    name: Technology
+    description: >-
+      Where the declared applications actually run and what materializes
+      them.
+  - id: implementation
+    name: Implementation
+    description: >-
+      How the planned architecture becomes real: work, deliverables, and
+      the plateaus between here and there.
   - id: hygiene
     name: Model hygiene
     description: Cross-cutting completeness that keeps every wave honest.
@@ -31,6 +44,7 @@ questions:
   # ---- motivation ----------------------------------------------------------
   - id: outcome-missing
     wave: motivation
+    since: "0.1"
     scope: workspace
     trigger:
       - condition: no-subject-of-kind
@@ -50,6 +64,7 @@ questions:
 
   - id: stakeholders-missing
     wave: motivation
+    since: "0.1"
     scope: workspace
     trigger:
       - condition: no-subject-of-kind
@@ -68,6 +83,7 @@ questions:
 
   - id: constraints-missing
     wave: motivation
+    since: "0.1"
     scope: workspace
     trigger:
       - condition: no-subject-of-kind
@@ -86,6 +102,7 @@ questions:
 
   - id: goal-unrealized
     wave: motivation
+    since: "0.1"
     scope: subject
     subjects:
       kinds:
@@ -110,6 +127,7 @@ questions:
 
   - id: goal-no-driver
     wave: motivation
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -137,6 +155,7 @@ questions:
 
   - id: driver-influences-nothing
     wave: motivation
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -158,6 +177,7 @@ questions:
 
   - id: stakeholder-unconcerned
     wave: motivation
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -180,6 +200,7 @@ questions:
 
   - id: requirement-unrealized
     wave: motivation
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -203,6 +224,7 @@ questions:
 
   - id: principle-unapplied
     wave: motivation
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -225,6 +247,7 @@ questions:
 
   - id: assessment-unlinked
     wave: motivation
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -243,6 +266,7 @@ questions:
 
   - id: motivation-unattested
     wave: motivation
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -268,6 +292,7 @@ questions:
   # ---- business ------------------------------------------------------------
   - id: service-consumer-unknown
     wave: business
+    since: "0.1"
     scope: subject
     subjects:
       kinds:
@@ -291,6 +316,7 @@ questions:
 
   - id: owner-missing
     wave: business
+    since: "0.1"
     scope: subject
     subjects:
       kinds:
@@ -313,6 +339,7 @@ questions:
 
   - id: actor-unassigned
     wave: business
+    since: "0.1"
     scope: subject
     subjects:
       kinds:
@@ -335,6 +362,7 @@ questions:
 
   - id: information-unaccessed
     wave: business
+    since: "0.1"
     scope: subject
     subjects:
       kinds:
@@ -358,6 +386,7 @@ questions:
 
   - id: no-service-declared
     wave: business
+    since: "0.1"
     scope: workspace
     trigger:
       - condition: no-subject-of-kind
@@ -378,6 +407,7 @@ questions:
 
   - id: service-realizes-no-motivation
     wave: business
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -405,6 +435,7 @@ questions:
 
   - id: process-untriggered
     wave: business
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -427,6 +458,7 @@ questions:
 
   - id: business-service-unrealized
     wave: business
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -460,6 +492,7 @@ questions:
   # ---- application ---------------------------------------------------------
   - id: app-service-unrealized
     wave: application
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -490,6 +523,7 @@ questions:
 
   - id: component-realizes-nothing
     wave: application
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -515,6 +549,7 @@ questions:
 
   - id: behavior-unassigned
     wave: application
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -546,6 +581,7 @@ questions:
 
   - id: event-triggers-nothing
     wave: application
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -568,6 +604,7 @@ questions:
 
   - id: information-unowned
     wave: application
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -589,6 +626,7 @@ questions:
 
   - id: planned-design-unattested
     wave: application
+    since: "0.3"
     scope: subject
     subjects:
       kinds:
@@ -612,9 +650,246 @@ questions:
       topic "design-review" (revoke by deleting it when the design
       changes).
 
+  # ---- technology ----------------------------------------------------------
+  - id: component-unhosted
+    wave: technology
+    since: "0.4"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationComponent
+      kindMatching: exact
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: missing-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+          - yarramate/core@0.1#assignment
+        direction: incoming
+        counterpartKinds:
+          - yarramate/core@0.1#node
+          - yarramate/core@0.1#device
+          - yarramate/core@0.1#systemSoftware
+          - yarramate/core@0.1#technologyService
+    question: >-
+      Where does {subject.name} run?
+    materiality: >-
+      The hosting boundary decides latency, failure domain, scaling
+      model, and data residency; a component with no declared runtime is
+      deployed by whoever gets there first. Matching is exact by intent:
+      profile-derived module kinds inherit their deployable parent's
+      hosting rather than answering separately.
+    authority: either
+    resolution: >-
+      Add the node, device, or system software that hosts it with a
+      serving or assignment relationship into the component.
+
+  - id: node-serves-nothing
+    wave: technology
+    since: "0.4"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#node
+        - yarramate/core@0.1#device
+        - yarramate/core@0.1#systemSoftware
+    trigger:
+      - condition: missing-relationship
+        kinds:
+          - yarramate/core@0.1#serving
+          - yarramate/core@0.1#assignment
+        direction: outgoing
+    question: >-
+      What does {subject.name} host or serve?
+    materiality: >-
+      Declared infrastructure that serves nothing is either cost without
+      purpose or missing the links that justify it; both change the
+      deployment budget.
+    authority: either
+    resolution: >-
+      Add serving or assignment relationships to the applications and
+      behavior it hosts, or remove it.
+
+  - id: technology-service-unrealized
+    wave: technology
+    since: "0.4"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#technologyService
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: missing-linkage
+        kinds:
+          - yarramate/core@0.1#realization
+        direction: incoming
+        counterpartKinds:
+          - yarramate/core@0.1#node
+          - yarramate/core@0.1#systemSoftware
+          - yarramate/core@0.1#technologyFunction
+          - yarramate/core@0.1#technologyProcess
+    question: >-
+      What provides {subject.name}?
+    materiality: >-
+      A technology service with no realizing node or behavior is a
+      dependency assumed rather than provided; outages and upgrades have
+      no owner in the model.
+    authority: either
+    resolution: >-
+      Add realization from the node, system software, or technology
+      behavior that provides the service.
+
+  - id: artifact-unassigned
+    wave: technology
+    since: "0.4"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#artifact
+      kindMatching: exact
+    trigger:
+      - condition: missing-relationship
+        kinds:
+          - yarramate/core@0.1#assignment
+          - yarramate/core@0.1#realization
+        direction: any
+    question: >-
+      What deploys {subject.name}, and what does it materialize?
+    materiality: >-
+      An artifact with no deployment target and nothing it realizes is a
+      build output the architecture cannot place; release engineering
+      starts from exactly these links.
+    authority: either
+    resolution: >-
+      Assign the artifact to the node that deploys it and add realization
+      to the component or data it materializes.
+
+  # ---- implementation ------------------------------------------------------
+  - id: workpackage-delivers-nothing
+    wave: implementation
+    since: "0.4"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#workPackage
+    trigger:
+      - condition: missing-relationship
+        kinds:
+          - yarramate/core@0.1#realization
+          - yarramate/core@0.1#aggregation
+        direction: outgoing
+    question: >-
+      What does {subject.name} produce?
+    materiality: >-
+      Work with no deliverable cannot be accepted or declared done; the
+      deliverable link is what makes progress reviewable rather than
+      reported.
+    authority: either
+    resolution: >-
+      Add realization from the work package to its deliverables.
+
+  - id: workpackage-unassigned
+    wave: implementation
+    since: "0.4"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#workPackage
+    trigger:
+      - condition: missing-linkage
+        kinds:
+          - yarramate/core@0.1#assignment
+        direction: incoming
+        counterpartKinds:
+          - yarramate/core@0.1#businessActor
+          - yarramate/core@0.1#businessRole
+    question: >-
+      Who is committed to {subject.name}?
+    materiality: >-
+      An unassigned work package is a plan without capacity; commitment
+      is the difference between a roadmap and a wish list.
+    authority: human
+    resolution: >-
+      Add assignment from the actor or role that owns the work.
+
+  - id: deliverable-realizes-nothing
+    wave: implementation
+    since: "0.4"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#deliverable
+      kindMatching: exact
+    trigger:
+      - condition: missing-relationship
+        kinds:
+          - yarramate/core@0.1#realization
+        direction: outgoing
+    question: >-
+      What does {subject.name} make real?
+    materiality: >-
+      A deliverable that realizes no architecture element is effort
+      disconnected from the design; its acceptance criteria cannot be
+      stated architecturally.
+    authority: either
+    resolution: >-
+      Add realization from the deliverable to the plateau, requirement,
+      or element it brings into being.
+
+  - id: plateau-aggregates-nothing
+    wave: implementation
+    since: "0.4"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#plateau
+    trigger:
+      - condition: missing-relationship
+        kinds:
+          - yarramate/core@0.1#aggregation
+          - yarramate/core@0.1#composition
+        direction: outgoing
+    question: >-
+      Which architecture does {subject.name} stabilize?
+    materiality: >-
+      A plateau that aggregates nothing describes no state anyone can
+      stand on; migration planning needs to know what is stable when.
+    authority: either
+    resolution: >-
+      Aggregate the elements that are current during this plateau, or use
+      architecture states instead and remove it.
+
+  - id: gap-unaddressed
+    wave: implementation
+    since: "0.4"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#gap
+    trigger:
+      - condition: missing-relationship
+        kinds:
+          - yarramate/core@0.1#association
+          - yarramate/core@0.1#realization
+        direction: any
+    question: >-
+      What closes {subject.name}?
+    materiality: >-
+      A named gap nothing addresses is a known risk with no plan; either
+      work closes it or the acceptance of it should be on record.
+    authority: human
+    resolution: >-
+      Associate the gap with the plateaus it separates and the
+      deliverable that closes it, or record the decision to accept it.
+
   # ---- hygiene -------------------------------------------------------------
   - id: concept-isolated
     wave: hygiene
+    since: "0.1"
     scope: subject
     subjects:
       kinds:
@@ -640,6 +915,7 @@ questions:
 
   - id: concept-undescribed
     wave: hygiene
+    since: "0.1"
     scope: subject
     subjects:
       kinds:
@@ -663,6 +939,7 @@ questions:
 
   - id: status-missing
     wave: hygiene
+    since: "0.1"
     scope: subject
     subjects:
       kinds:
@@ -685,6 +962,7 @@ questions:
 
   - id: states-undefined
     wave: hygiene
+    since: "0.1"
     scope: workspace
     trigger:
       - condition: no-state-defined

package/dist/apply-command.js

@@ -1,6 +1,6 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { isSeq, parseDocument } from 'yaml';
+import { isMap, isScalar, isSeq, parseDocument, stringify, } from 'yaml';
 import Ajv2020Module from 'ajv/dist/2020.js';
 import { diagnosticJson, humanDiagnostics, usage, } from './cli-support.js';
 import { compileWorkspace } from './compiler.js';
@@ -11,48 +11,170 @@ import operationsSchema from '../schema/yarramate-operations.schema.json' with {
 };
 const Ajv2020 = Ajv2020Module.default;
 const validateOperations = new Ajv2020({ allErrors: true }).compile(operationsSchema);
-// Scalar fields replace; list fields append. An answer enriches what is
-// there — it never silently shrinks it (removals stay Git edits).
+// Scalar fields replace; list fields append; `remove` retracts (ADR 0062).
+// An answer enriches what is there and may explicitly take back what it
+// asserted — it never silently shrinks anything.
 const SCALAR_CONCEPT_FIELDS = ['kind', 'name', 'description', 'status', 'owner'];
 const LIST_CONCEPT_FIELDS = ['constraints', 'references', 'presentIn', 'attestations'];
 const SCALAR_RELATIONSHIP_FIELDS = ['kind', 'from', 'to', 'name', 'description', 'status', 'mode', 'content'];
 const LIST_RELATIONSHIP_FIELDS = ['references', 'presentIn'];
-const appendBlockItem = (document, collection, item) => {
-    document.addIn([collection], item);
-    const sequence = document.getIn([collection], true);
-    if (isSeq(sequence)) {
-        sequence.flow = false;
+// ---------------------------------------------------------------------------
+// The splice layer. Every operation becomes a minimal text edit against the
+// document's current source, so bytes the batch never touched stay
+// byte-identical — an apply diff is exactly the answer it landed (#114).
+// The atomic compile gate below validates the spliced text itself, so any
+// splice defect rejects the batch loudly instead of corrupting a document.
+const lineStartOf = (source, offset) => source.lastIndexOf('\n', offset - 1) + 1;
+const indentAt = (source, offset) => offset - lineStartOf(source, offset);
+// End of the last line a node occupies, extended through its newline.
+const lineEndAfter = (source, offset) => {
+    const newline = source.indexOf('\n', Math.max(offset - 1, 0));
+    return newline === -1 ? source.length : newline + 1;
+};
+const reindent = (text, indent) => text.split('\n').join(`\n${' '.repeat(indent)}`);
+// A plain value as YAML source. lineWidth 0 keeps strings we author on one
+// line; genuinely multi-line strings become block scalars and are re-indented
+// by the caller.
+const valueText = (value) => stringify(value, { lineWidth: 0 }).trimEnd();
+const pairFor = (map, key) => map.items.find((pair) => isScalar(pair.key) && pair.key.value === key);
+const nodeRange = (node) => {
+    const range = node.range;
+    if (range === undefined) {
+        throw new Error('YAML node has no source range');
+    }
+    return range;
+};
+// Renders `items` as block sequence entries at the given marker indent.
+const sequenceEntries = (items, markerIndent) => {
+    const rendered = stringify(items, { lineWidth: 0 }).trimEnd();
+    return `${' '.repeat(markerIndent)}${reindent(rendered, markerIndent)}`;
+};
+const splice = (source, start, end, text) => source.slice(0, start) + text + source.slice(end);
+// Insert a newline-terminated block at a line boundary, tolerating a
+// source that does not end in a newline.
+const insertBlock = (source, insertAt, block) => splice(source, insertAt, insertAt, insertAt > 0 && source[insertAt - 1] !== '\n' ? `\n${block}` : block);
+// Node ranges may extend past their trailing newline to the start of the
+// next line; anchor insertions on the last CONTENT line instead.
+const afterContentLine = (source, offset) => {
+    let anchor = offset;
+    while (anchor > 0 && source[anchor - 1] === '\n')
+        anchor -= 1;
+    return lineEndAfter(source, anchor);
+};
+// Where a new field of an item lands: after the last line of the item's
+// final pair.
+const itemFieldInsertAt = (source, map) => {
+    const lastPair = map.items[map.items.length - 1];
+    const anchor = lastPair.value === null || lastPair.value === undefined
+        ? nodeRange(lastPair.key)[2]
+        : nodeRange(lastPair.value)[1];
+    return afterContentLine(source, anchor);
+};
+// Appends one item to a top-level block collection (`concepts:` or
+// `relationships:`), creating or converting the collection when needed.
+const appendCollectionItem = (source, collection, item) => {
+    const document = parseDocument(source);
+    const root = document.contents;
+    if (!isMap(root))
+        throw new Error('Document root is not a mapping');
+    const pair = pairFor(root, collection);
+    if (pair === undefined) {
+        const base = source.endsWith('\n') ? source : `${source}\n`;
+        return `${base}${collection}:\n${sequenceEntries([item], 2)}\n`;
+    }
+    const sequence = pair.value;
+    if (isSeq(sequence) && !sequence.flow && sequence.items.length > 0) {
+        const lastItem = sequence.items[sequence.items.length - 1];
+        const markerIndent = indentAt(source, nodeRange(lastItem)[0]) - 2;
+        const insertAt = lineEndAfter(source, nodeRange(lastItem)[2]);
+        return insertBlock(source, insertAt, `${sequenceEntries([item], markerIndent)}\n`);
     }
+    if (!isSeq(sequence)) {
+        // `concepts:` with no value at all: append the block under the key.
+        const insertAt = lineEndAfter(source, nodeRange(pair.key)[2]);
+        return insertBlock(source, insertAt, `${sequenceEntries([item], 2)}\n`);
+    }
+    // Empty or flow collection: replace the whole value with a block
+    // sequence carrying any existing entries plus the new one, consuming
+    // the space that separated it from the key.
+    const existing = sequence.items.length > 0
+        ? sequence.toJSON()
+        : [];
+    let [start] = nodeRange(sequence);
+    const valueEnd = nodeRange(sequence)[1];
+    while (start > 0 && source[start - 1] === ' ')
+        start -= 1;
+    return splice(source, start, valueEnd, `\n${sequenceEntries([...existing, item], 2)}`);
 };
-const findItem = (document, collection, id) => {
-    const sequence = document.get(collection, true);
-    if (!isSeq(sequence))
+const itemMap = (source, collection, id) => {
+    const document = parseDocument(source);
+    const root = document.contents;
+    if (!isMap(root))
+        return undefined;
+    const pair = pairFor(root, collection);
+    if (pair === undefined || !isSeq(pair.value))
         return undefined;
-    return sequence.items.find((item) => typeof item === 'object' &&
-        item !== null &&
-        'get' in item &&
-        item.get('id') === id);
+    const found = pair.value.items.find((candidate) => isMap(candidate) &&
+        candidate.items.some((field) => isScalar(field.key) &&
+            field.key.value === 'id' &&
+            isScalar(field.value) &&
+            field.value.value === id));
+    return found === undefined ? undefined : { map: found };
 };
-const applyFields = (document, item, fields, scalars, lists) => {
-    for (const key of scalars) {
-        if (fields[key] !== undefined)
-            item.set(key, fields[key]);
+// The indent item fields sit at, read off the item's own first field.
+const fieldIndentOf = (source, map) => indentAt(source, nodeRange(map.items[0].key)[0]);
+const setScalarField = (source, map, key, value) => {
+    const indent = fieldIndentOf(source, map);
+    const rendered = reindent(valueText(value), indent + 2);
+    const pair = pairFor(map, key);
+    if (pair === undefined) {
+        return insertBlock(source, itemFieldInsertAt(source, map), `${' '.repeat(indent)}${key}: ${rendered}\n`);
     }
-    for (const key of lists) {
-        const additions = fields[key];
-        if (additions === undefined || additions.length === 0)
-            continue;
-        const existing = item.get(key);
-        if (existing === undefined) {
-            item.set(key, additions);
-        }
-        else if (isSeq(existing)) {
-            for (const entry of additions) {
-                existing.items.push(document.createNode(entry));
-            }
-        }
+    const [start, valueEnd] = nodeRange(pair.value);
+    return splice(source, start, valueEnd, rendered);
+};
+const appendListField = (source, map, key, additions) => {
+    const indent = fieldIndentOf(source, map);
+    const pair = pairFor(map, key);
+    if (pair === undefined) {
+        return insertBlock(source, itemFieldInsertAt(source, map), `${' '.repeat(indent)}${key}:\n${sequenceEntries(additions, indent + 2)}\n`);
+    }
+    const sequence = pair.value;
+    if (isSeq(sequence) && !sequence.flow && sequence.items.length > 0) {
+        const lastItem = sequence.items[sequence.items.length - 1];
+        const markerIndent = indentAt(source, nodeRange(lastItem)[0]) - 2;
+        const insertAt = lineEndAfter(source, nodeRange(lastItem)[2]);
+        return insertBlock(source, insertAt, `${sequenceEntries(additions, markerIndent)}\n`);
     }
+    const existing = isSeq(sequence) && sequence.items.length > 0
+        ? sequence.toJSON()
+        : [];
+    const merged = [...existing, ...additions];
+    const [start, valueEnd] = isSeq(sequence)
+        ? nodeRange(sequence)
+        : nodeRange(pair.value);
+    if (isSeq(sequence) && sequence.flow) {
+        const flow = stringify(merged, {
+            collectionStyle: 'flow',
+            lineWidth: 0,
+        }).trimEnd();
+        return splice(source, start, valueEnd, flow);
+    }
+    return splice(source, start, valueEnd, `\n${sequenceEntries(merged, indent + 2)}`);
+};
+// Retraction (#115): delete the field's whole entry, from the start of its
+// key line through the end of its value's last line.
+const removeField = (source, map, key) => {
+    const pair = pairFor(map, key);
+    if (pair === undefined)
+        return undefined;
+    const start = lineStartOf(source, nodeRange(pair.key)[0]);
+    const valueEnd = pair.value === null || pair.value === undefined
+        ? nodeRange(pair.key)[2]
+        : nodeRange(pair.value)[2];
+    return splice(source, start, lineEndAfter(source, valueEnd), '');
 };
+// ---------------------------------------------------------------------------
 export function runApplyCommand(options, cwd) {
     const json = options.includes('--json');
     const rest = options.filter((option) => option !== '--json');
@@ -91,7 +213,7 @@ export function runApplyCommand(options, cwd) {
         // Documents are addressed by their manifest paths; an operation aimed
         // anywhere else is rejected before anything is touched.
         const workspaceDocuments = new Map(workspace.documents.map((path) => [resolve(cwd, path), path]));
-        const parsed = new Map();
+        const candidates = new Map();
         const counts = {
             addedConcepts: 0,
             addedRelationships: 0,
@@ -112,35 +234,63 @@ export function runApplyCommand(options, cwd) {
                     locate(`Operation ${index} targets "${operation.document}", which is not a document of workspace "${workspace.id}"`),
                 ]);
             }
-            let document = parsed.get(absolute);
-            if (document === undefined) {
-                document = parseDocument(readFileSync(absolute, 'utf8'));
-                parsed.set(absolute, document);
+            let source = candidates.get(absolute);
+            if (source === undefined) {
+                source = readFileSync(absolute, 'utf8');
             }
             if (operation.op === 'add-concept') {
-                appendBlockItem(document, 'concepts', operation.concept);
+                source = appendCollectionItem(source, 'concepts', operation.concept);
                 counts.addedConcepts += 1;
             }
             else if (operation.op === 'add-relationship') {
-                appendBlockItem(document, 'relationships', operation.relationship);
+                source = appendCollectionItem(source, 'relationships', operation.relationship);
                 counts.addedRelationships += 1;
             }
             else {
                 const collection = operation.op === 'update-concept' ? 'concepts' : 'relationships';
-                const payload = operation.op === 'update-concept'
+                const payload = (operation.op === 'update-concept'
                     ? operation.concept
-                    : operation.relationship;
-                const item = findItem(document, collection, payload.id);
-                if (item === undefined) {
+                    : operation.relationship);
+                const scalars = operation.op === 'update-concept'
+                    ? SCALAR_CONCEPT_FIELDS
+                    : SCALAR_RELATIONSHIP_FIELDS;
+                const lists = operation.op === 'update-concept'
+                    ? LIST_CONCEPT_FIELDS
+                    : LIST_RELATIONSHIP_FIELDS;
+                const id = payload.id;
+                const removals = operation.remove ?? [];
+                const contradiction = removals.find((key) => payload[key] !== undefined);
+                if (contradiction !== undefined) {
                     return failed([
-                        locate(`Operation ${index} updates "${payload.id}", which does not exist in ${operation.document}`),
+                        locate(`Operation ${index} both sets and removes "${contradiction}" on "${id}"`),
                     ]);
                 }
-                applyFields(document, item, payload, operation.op === 'update-concept'
-                    ? SCALAR_CONCEPT_FIELDS
-                    : SCALAR_RELATIONSHIP_FIELDS, operation.op === 'update-concept'
-                    ? LIST_CONCEPT_FIELDS
-                    : LIST_RELATIONSHIP_FIELDS);
+                const located = itemMap(source, collection, id);
+                if (located === undefined) {
+                    return failed([
+                        locate(`Operation ${index} updates "${id}", which does not exist in ${operation.document}`),
+                    ]);
+                }
+                for (const key of scalars) {
+                    if (payload[key] === undefined)
+                        continue;
+                    source = setScalarField(source, itemMap(source, collection, id).map, key, payload[key]);
+                }
+                for (const key of lists) {
+                    const additions = payload[key];
+                    if (additions === undefined || additions.length === 0)
+                        continue;
+                    source = appendListField(source, itemMap(source, collection, id).map, key, additions);
+                }
+                for (const key of removals) {
+                    const removed = removeField(source, itemMap(source, collection, id).map, key);
+                    if (removed === undefined) {
+                        return failed([
+                            locate(`Operation ${index} removes "${key}", which is not set on "${id}"`),
+                        ]);
+                    }
+                    source = removed;
+                }
                 if (operation.op === 'update-concept') {
                     counts.updatedConcepts += 1;
                 }
@@ -148,13 +298,10 @@ export function runApplyCommand(options, cwd) {
                     counts.updatedRelationships += 1;
                 }
             }
+            candidates.set(absolute, source);
         }
         // The atomic gate: the whole candidate workspace must compile before a
         // single byte is written; any diagnostic rejects the entire batch.
-        const candidates = new Map([...parsed.entries()].map(([absolute, document]) => [
-            absolute,
-            document.toString({ lineWidth: 0 }),
-        ]));
         const compilation = compileWorkspace([...workspace.profiles, ...workspace.documents].map((path) => {
             const absolute = resolve(cwd, path);
             return {
@@ -167,7 +314,7 @@ export function runApplyCommand(options, cwd) {
         for (const [absolute, source] of candidates) {
             writeFileSync(absolute, source, 'utf8');
         }
-        const touched = [...parsed.keys()]
+        const touched = [...candidates.keys()]
             .map((absolute) => workspaceDocuments.get(absolute))
             .sort();
         if (json) {

package/dist/design-command.js

@@ -33,6 +33,7 @@ const selectStep = (report, subjectFilter) => {
                     question: question.question,
                     materiality: question.materiality,
                     resolution: question.resolution,
+                    ...(question.since === undefined ? {} : { since: question.since }),
                 };
             }
             const subjects = subjectFilter === undefined
@@ -49,6 +50,7 @@ const selectStep = (report, subjectFilter) => {
                 question: first.question,
                 materiality: question.materiality,
                 resolution: question.resolution,
+                ...(question.since === undefined ? {} : { since: question.since }),
                 subject: {
                     id: first.id,
                     ...(first.name === undefined ? {} : { name: first.name }),
@@ -56,6 +58,10 @@ const selectStep = (report, subjectFilter) => {
                 ...(subjects.length > 1
                     ? { remainingSubjects: subjects.length - 1 }
                     : {}),
+                // The full roster sharing this question (#116): when one policy
+                // answer covers many subjects, the harness can collect it once
+                // and land one apply batch instead of interviewing N times.
+                openSubjects: subjects.map(({ id }) => id),
             };
         }
     }

package/dist/interrogate-command.d.ts

@@ -44,6 +44,7 @@ export interface CatalogueQuestion {
     readonly materiality: string;
     readonly resolution: string;
     readonly authority: 'human' | 'agent' | 'either';
+    readonly since?: string;
 }
 export interface QuestionCatalogue {
     readonly format: 'yarramate/question-catalogue/v1';
@@ -74,6 +75,7 @@ interface ReportQuestion {
     readonly question: string;
     readonly materiality: string;
     readonly resolution: string;
+    readonly since?: string;
     readonly subjects?: readonly OpenSubject[];
 }
 export interface InterrogationReport {

package/dist/interrogate-command.js

@@ -175,6 +175,7 @@ export function evaluateCatalogue(catalogue, graph, profileContext) {
                 question: question.question.trim(),
                 materiality: question.materiality.trim(),
                 resolution: question.resolution.trim(),
+                ...(question.since === undefined ? {} : { since: question.since }),
             };
             if (question.scope === 'workspace') {
                 const isOpen = question.trigger.every((condition) => conditionHolds(index, condition, undefined, profileContext));
@@ -253,12 +254,13 @@ export function renderInterrogationReport(report) {
                 lines.push(`  closed ${question.id}`);
                 continue;
             }
+            const sinceMarker = question.since === undefined ? '' : ` [since ${question.since}]`;
             if (question.subjects === undefined) {
-                lines.push(`  OPEN   ${question.id} — ${question.question}`);
+                lines.push(`  OPEN   ${question.id}${sinceMarker} — ${question.question}`);
                 lines.push(`         why: ${question.materiality}`);
                 continue;
             }
-            lines.push(`  OPEN   ${question.id} (${question.subjects.length} ${question.subjects.length === 1 ? 'subject' : 'subjects'})`);
+            lines.push(`  OPEN   ${question.id}${sinceMarker} (${question.subjects.length} ${question.subjects.length === 1 ? 'subject' : 'subjects'})`);
             for (const subject of question.subjects) {
                 lines.push(`         ask: "${subject.question}" [authority: ${question.authority}]`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yarramate",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Tool-neutral semantic architecture engine and guided methodology",
   "license": "MIT",
   "repository": {

package/schema/yarramate-design-step.schema.json

@@ -139,6 +139,17 @@
             "remainingSubjects": {
               "type": "integer",
               "minimum": 1
+            },
+            "openSubjects": {
+              "type": "array",
+              "minItems": 1,
+              "items": {
+                "type": "string",
+                "minLength": 1
+              }
+            },
+            "since": {
+              "type": "string"
             }
           }
         }

package/schema/yarramate-interrogation-report.schema.json

@@ -68,6 +68,7 @@
         "question": { "type": "string", "minLength": 1 },
         "materiality": { "type": "string", "minLength": 1 },
         "resolution": { "type": "string", "minLength": 1 },
+        "since": { "type": "string" },
         "subjects": {
           "type": "array",
           "minItems": 1,

package/schema/yarramate-operations.schema.json

@@ -264,6 +264,22 @@
                   "type": "object"
                 }
               ]
+            },
+            "remove": {
+              "type": "array",
+              "minItems": 1,
+              "items": {
+                "enum": [
+                  "name",
+                  "description",
+                  "status",
+                  "owner",
+                  "constraints",
+                  "references",
+                  "presentIn",
+                  "attestations"
+                ]
+              }
             }
           }
         },
@@ -294,6 +310,21 @@
                   "type": "object"
                 }
               ]
+            },
+            "remove": {
+              "type": "array",
+              "minItems": 1,
+              "items": {
+                "enum": [
+                  "name",
+                  "description",
+                  "status",
+                  "mode",
+                  "content",
+                  "references",
+                  "presentIn"
+                ]
+              }
             }
           }
         }

package/schema/yarramate-question-catalogue.schema.json

@@ -392,6 +392,11 @@
         "resolution": {
           "description": "Guidance for how an accepted answer should land as native authoring (which claim, relationship, or state to add).",
           "$ref": "#/$defs/nonEmptyText"
+        },
+        "since": {
+          "description": "The catalogue version this question first appeared in. Lets consumers distinguish 'the catalogue deepened' from 'the model regressed' when a completed interview reopens (ADR 0063).",
+          "type": "string",
+          "pattern": "^[0-9]+\\.[0-9]+$"
         }
       },
       "allOf": [

package/skills/yarramate-architecture/SKILL.md

@@ -129,7 +129,11 @@ yarramate design .yarramate/workspace.yaml
    .yarramate/workspace.yaml`), then re-run `design` — the next question is
    recomputed from the model, so the loop is resumable across sessions and
    agents with no handover. Use `--subject <id>` to focus the interview on
-   one element. The interview is complete when `design` says so.
+   one element. When a step reports many `openSubjects` sharing one
+   question (ownership is the classic case), do not interview N times:
+   collect the policy answer once — "who owns what, by area" — and land it
+   across every listed subject as one apply batch. The interview is
+   complete when `design` says so.
 5. Create:
    - an alternatives projection for the decision;
    - a bounded target projection for implementation agents.