@event4u/agent-config 9.11.0 → 9.13.0

package/dist/agent-src/skills/video-director/SKILL.md

@@ -1,7 +1,7 @@
 ---
 model_tier: inherit
 name: video-director
-description: "Use when turning a scene idea into the 11-block cinematic prompt for live-action AI video — lens, lighting, blocking, motion, negatives. Triggers 'cinematic prompt', 'film-grade scene'."
+description: "Use when a live-action beat becomes the 11-block cinematic prompt — lens, lighting, negatives. Triggers 'cinematic prompt', 'film-grade scene'. Animated → pixar-storyteller; 12-block → scene-expander."
 personas:
   - hollywood-director
 domain: product
@@ -124,13 +124,16 @@ Any "no" → revise that block before handing off.
 
 ## Policies
 
+Paths, enforcement model, and the full set: the
+[media policy preamble](../../../agents/settings/policies/media/README.md).
+
 The 11-block cinematic prompt is live-action shape — real-person and brand-impersonation risks are the highest in the cluster. Before emitting:
 
-- [`agents/settings/policies/media/likeness.md`](../../../agents/settings/policies/media/likeness.md) — when the prompt names or visually identifies a real person on camera.
-- [`agents/settings/policies/media/public-figures.md`](../../../agents/settings/policies/media/public-figures.md) — when the subject is a recognised public figure.
-- [`agents/settings/policies/media/brand-impersonation.md`](../../../agents/settings/policies/media/brand-impersonation.md) — when the prompt copies a journalism / broadcaster / regulated-industry visual identity.
-- [`agents/settings/policies/media/style.md`](../../../agents/settings/policies/media/style.md) — when LIGHT / LENS choices are anchored to a named living cinematographer's signature.
-- [`agents/settings/policies/media/disclosure.md`](../../../agents/settings/policies/media/disclosure.md) — every distributed live-action AI clip carries the non-removable AI-generation disclosure.
+- **`likeness`** — when the prompt names or visually identifies a real person on camera.
+- **`public-figures`** — when the subject is a recognised public figure.
+- **`brand-impersonation`** — when the prompt copies a journalism / broadcaster / regulated-industry visual identity.
+- **`style`** — when LIGHT / LENS choices are anchored to a named living cinematographer's signature.
+- **`disclosure`** — every distributed live-action AI clip carries the non-removable AI-generation disclosure.
 
 Refuse-and-surface at the directorial layer; live-action realism amplifies every policy gap downstream.
 

package/dist/agent-src/templates/agents/agent-project-settings.example.yml

@@ -39,7 +39,7 @@ schema_version: 1
 # CI guard: a release bump of `package.json` must update this value
 # in lockstep — see scripts/check_template_pin_drift.ts (road-to-
 # portable-runtime-and-update-check P3.3).
-agent_config_version: "9.11.0"
+agent_config_version: "9.13.0"
 
 # --- Project identity ---
 project:

package/dist/agent-src/templates/scripts/work_engine/directives/ui/apply.ts

@@ -17,9 +17,9 @@ import {
     StepResult,
     agent_directive,
 } from '../../delivery_state.js';
-import { placeholder_paths } from './design.js';
+import { has_design_system, placeholder_paths, provided_artifact } from './design.js';
 import {
-    UNSUPPORTED_LANE,
+    is_ambiguous_stack,
     bundle_line,
     unsupported_stack_questions,
 } from './stack_bundles.js';
@@ -51,6 +51,17 @@ export const AMBIGUITIES: ReadonlyArray<Record<string, string>> = [
             'agent directive `ui-apply-<stack>` → skill ' +
             'bundle implements the brief and writes the envelope back',
     },
+    {
+        code: 'apply_coverage_missing',
+        trigger:
+            'a provided artifact is in state.ui_design but the ui_apply ' +
+            'envelope carries no coverage report, or the report leaves a ' +
+            'declared interaction / keyframe / asset unaccounted for',
+        resolution:
+            'agent writes ui_apply.coverage = {honoured: [], translated: [], ' +
+            'flagged: []} naming every declared item exactly once — a dropped ' +
+            'handler belongs in `flagged`, never in silence',
+    },
     {
         code: 'apply_placeholders_in_output',
         trigger:
@@ -89,10 +100,122 @@ export function run(state: DeliveryState): StepResult {
         return _halt_placeholders(state, violations);
     }
 
+    const provided = provided_artifact(state.ui_design as Record<string, Any> | null);
+    if (provided !== null) {
+        const gaps = coverage_gaps(provided, envelope['coverage']);
+        if (gaps.length > 0) {
+            return _halt_coverage(state, provided, gaps);
+        }
+    }
+
     _record_changes(state, envelope);
     return new StepResult({ outcome: Outcome.SUCCESS });
 }
 
+/** Buckets the coverage report must sort every declared item into. */
+export const COVERAGE_BUCKETS: ReadonlyArray<string> = ['honoured', 'translated', 'flagged'];
+
+/** Declared-item lists a port has to account for, in report order. */
+export const COVERED_INVENTORIES: ReadonlyArray<string> = [
+    'interactions',
+    'keyframes',
+    'assets',
+];
+
+/**
+ * Return every reason the coverage report fails to account for the artifact.
+ *
+ * The fidelity ledger the port case never had. `apply` used to validate its
+ * output with a single placeholder substring scan and nothing else, so a
+ * dropped handler or a lost keyframe left no trace anywhere — the loss was
+ * structurally silent, not merely unreported. Requiring each declared item to
+ * appear in exactly one bucket turns that silence into a halt: a handler the
+ * port could not carry has to be written down in `flagged`.
+ *
+ * Matching is substring containment against the bucket entries, so an entry
+ * may carry its own explanation ("submit handler — translated to a form
+ * action") and still count as accounting for `submit handler`.
+ */
+export function coverage_gaps(
+    provided: Record<string, Any>,
+    coverage: Any,
+): string[] {
+    const gaps: string[] = [];
+    if (!_isDict(coverage)) {
+        return [
+            'no `coverage` report in the apply envelope — a provided artifact ' +
+                'requires one',
+        ];
+    }
+    const entries: string[] = [];
+    for (const bucket of COVERAGE_BUCKETS) {
+        const value = coverage[bucket];
+        if (value === undefined) {
+            gaps.push(`\`coverage.${bucket}\` is missing (use an empty list if nothing qualifies)`);
+            continue;
+        }
+        if (!Array.isArray(value)) {
+            gaps.push(`\`coverage.${bucket}\` must be a list of strings`);
+            continue;
+        }
+        for (const item of value) {
+            if (typeof item === 'string' && item !== '') {
+                entries.push(item.toLowerCase());
+            }
+        }
+    }
+    for (const inventory of COVERED_INVENTORIES) {
+        const declared = provided[inventory];
+        if (!Array.isArray(declared)) continue;
+        for (const item of declared) {
+            if (typeof item !== 'string' || item === '') continue;
+            const needle = item.toLowerCase();
+            if (!entries.some((entry) => entry.includes(needle))) {
+                gaps.push(
+                    `\`${inventory}\`: \`${item}\` appears in no coverage bucket`,
+                );
+            }
+        }
+    }
+    return gaps;
+}
+
+/** BLOCKED halt — the port did not account for what the artifact declared. */
+function _halt_coverage(
+    state: DeliveryState,
+    provided: Record<string, Any>,
+    gaps: string[],
+): StepResult {
+    const directive = _resolve_directive(state);
+    const contract = has_design_system(provided)
+        ? 'A `design-system.json` came with this artifact, so its token values ' +
+          'are honoured verbatim — say which, and which you had to translate.'
+        : 'No `design-system.json` came with this artifact, so every token ' +
+          'value you did not read from it belongs in `translated` or `flagged`.';
+    const lines: string[] = [
+        agent_directive(directive),
+        '> Apply rejected: this is a port of a provided artifact, and the ' +
+            'coverage report does not account for it.',
+        `> ${contract}`,
+        '> Unaccounted:',
+    ];
+    for (const gap of gaps) {
+        lines.push(`> - ${gap}`);
+    }
+    lines.push(
+        '> Write `ui_apply.coverage = {honoured: [...], translated: [...], ' +
+            'flagged: [...]}` naming every declared interaction, keyframe, and ' +
+            'asset exactly once. A handler the port could not carry goes in ' +
+            '`flagged` with the reason — never in silence.',
+    );
+    return new StepResult({
+        outcome: Outcome.BLOCKED,
+        questions: lines,
+        message:
+            `UI apply rejected: ${gaps.length} coverage gap(s) against the provided artifact.`,
+    });
+}
+
 /** Return the agent-written `ui_apply` envelope, or `null`. */
 function _apply_envelope(state: DeliveryState): Record<string, Any> | null {
     const data = _pyTruthy(state.ticket) ? state.ticket : {};
@@ -132,27 +255,49 @@ function _placeholder_violations_in_output(envelope: Record<string, Any>): strin
 function _delegate_to_stack_skill(state: DeliveryState): StepResult {
     const directive = _resolve_directive(state);
     const stack_label = _stack_label(state);
-    if (stack_label === UNSUPPORTED_LANE) {
+    if (is_ambiguous_stack(state.stack)) {
+        const conflicts = ((state.stack as Record<string, Any>)['ambiguity'] ??
+            []) as ReadonlyArray<string>;
         return new StepResult({
             outcome: Outcome.BLOCKED,
-            questions: unsupported_stack_questions('apply'),
-            message: 'UI apply refused: frontend framework not modelled by any lane.',
+            questions: unsupported_stack_questions('apply', conflicts),
+            message:
+                `UI apply halted: detection is ambiguous (${conflicts.join('; ')}) — ` +
+                'the open question is which project to build for.',
         });
     }
+    const provided = provided_artifact(state.ui_design as Record<string, Any> | null);
+    const lines: string[] = [
+        agent_directive(directive),
+        `> Stack: \`${stack_label}\`. Implementing the locked design brief.`,
+        bundle_line(state.stack, 'build', stack_label),
+        '> Microcopy is locked — every button label, empty-state ' +
+            'message, and validation message must come verbatim from ' +
+            '`state.ui_design.microcopy`.',
+    ];
+    if (provided !== null) {
+        lines.push(
+            '> This is a **port**: `state.ui_design.provided_artifact` is the ' +
+                'spec. Build it 1:1' +
+                (has_design_system(provided)
+                    ? ', and read token values from its `design_system` rather ' +
+                      'than re-deriving them.'
+                    : '; no `design_system` came with it, so anything you cannot ' +
+                      'read from the artifact is a translation you have to name.'),
+            '> The envelope must carry `coverage: {honoured, translated, ' +
+                'flagged}` accounting for every declared interaction, keyframe, ' +
+                'and asset exactly once — apply rejects the envelope otherwise.',
+        );
+    }
+    lines.push(
+        '> 1. Continue — implement the brief and write a ' +
+            '`ui_apply` envelope back into state.ticket ' +
+            '(rendered: {path: text}, files: [...])',
+        '> 2. Abort — drop this UI request',
+    );
     return new StepResult({
         outcome: Outcome.BLOCKED,
-        questions: [
-            agent_directive(directive),
-            `> Stack: \`${stack_label}\`. Implementing the locked design brief.`,
-            bundle_line(stack_label, 'build'),
-            '> Microcopy is locked — every button label, empty-state ' +
-                'message, and validation message must come verbatim from ' +
-                '`state.ui_design.microcopy`.',
-            '> 1. Continue — implement the brief and write a ' +
-                '`ui_apply` envelope back into state.ticket ' +
-                '(rendered: {path: text}, files: [...])',
-            '> 2. Abort — drop this UI request',
-        ],
+        questions: lines,
         message: `UI apply pending; delegating to \`${directive}\` for stack \`${stack_label}\`.`,
     });
 }

package/dist/agent-src/templates/scripts/work_engine/directives/ui/design.ts

@@ -44,6 +44,33 @@ export const PLACEHOLDER_PATTERNS: ReadonlyArray<string> = [
     'xxx',
 ];
 
+/**
+ * Optional brief key carrying a user-supplied design artifact.
+ *
+ * The brief's five required keys are a lossy projection of a finished
+ * artifact: `layout` is prose, not a spacing scale, and there is no slot at
+ * all for easing, hover behaviour, handlers, or assets. Before this key the
+ * pipeline had no channel for a handed-over design, so it rebuilt one from
+ * the five-key abstraction and said nothing about the difference. This slot
+ * is that channel — one more input to the same step, never a parallel track.
+ */
+export const PROVIDED_ARTIFACT_KEY = 'provided_artifact';
+
+/**
+ * What the five-key brief cannot carry from a provided artifact.
+ *
+ * Stated to the user **before** any regeneration, not discovered afterwards.
+ * A supplied `design-system.json` closes the first two; the rest are closed
+ * only by the coverage report `apply` demands.
+ */
+export const UNCARRIED_BY_THE_BRIEF: ReadonlyArray<string> = [
+    'exact spacing values — `layout` is prose, not a scale',
+    'easing curves and animation timing',
+    'hover / focus / active behaviour',
+    'event handlers and the interactions they drive',
+    'the asset manifest (images, icons, fonts the artifact references)',
+];
+
 export const AMBIGUITIES: ReadonlyArray<Record<string, string>> = [
     {
         code: 'design_missing',
@@ -61,6 +88,17 @@ export const AMBIGUITIES: ReadonlyArray<Record<string, string>> = [
             'agent re-runs the brief with final strings; ' +
             'halt lists the offending microcopy keys',
     },
+    {
+        code: 'design_provided_without_contract',
+        trigger:
+            'state.ui_design.provided_artifact is set but carries no ' +
+            'design_system, and the loss has not been acknowledged — the ' +
+            'brief would silently regenerate what it cannot carry',
+        resolution:
+            'user supplies a design-system.json (honoured verbatim), or ' +
+            'acknowledges the named losses so the port proceeds with them ' +
+            'stated up front',
+    },
     {
         code: 'design_unconfirmed',
         trigger: 'brief is well-formed but design_confirmed is unset/False',
@@ -123,6 +161,11 @@ export function run(state: DeliveryState): StepResult {
         return _halt_placeholders(state, placeholders);
     }
 
+    const provided = provided_artifact(designDict);
+    if (provided !== null && !_contract_or_loss_acknowledged(provided)) {
+        return _halt_provided_without_contract(state, provided);
+    }
+
     if (designDict['design_confirmed'] === true) {
         return new StepResult({ outcome: Outcome.SUCCESS });
     }
@@ -238,6 +281,81 @@ function _walk_placeholders(node: Any, prefix: string, violations: string[]): vo
     }
 }
 
+/**
+ * Return the supplied-artifact envelope, or `null` when none was handed over.
+ *
+ * Exported because `apply` needs the same answer — the coverage report it
+ * demands exists only for a port, and a second copy of "is this a port?"
+ * would be the drift this package has paid for before (see the shared
+ * `placeholder_paths` walker above).
+ */
+export function provided_artifact(
+    design: Record<string, Any> | null | undefined,
+): Record<string, Any> | null {
+    if (!_isDict(design)) return null;
+    const provided = design[PROVIDED_ARTIFACT_KEY];
+    if (!_isDict(provided) || Object.keys(provided).length === 0) return null;
+    return provided;
+}
+
+/** True when a machine-readable contract came with the artifact. */
+export function has_design_system(provided: Record<string, Any>): boolean {
+    return _isDict(provided['design_system']) && _pyTruthy(provided['design_system']);
+}
+
+/** The port may proceed: either a contract exists, or the losses were stated and accepted. */
+function _contract_or_loss_acknowledged(provided: Record<string, Any>): boolean {
+    return has_design_system(provided) || provided['loss_acknowledged'] === true;
+}
+
+/**
+ * BLOCKED halt — an artifact was handed over with no contract behind it.
+ *
+ * This is the honest-refusal branch. The pipeline *can* rebuild the artifact
+ * from the five-key brief; what it must not do is rebuild it silently. The
+ * halt names every value the brief cannot carry, then asks. Answering
+ * option 1 sets `loss_acknowledged` and the same losses are on the record.
+ */
+function _halt_provided_without_contract(
+    state: DeliveryState,
+    provided: Record<string, Any>,
+): StepResult {
+    const preview = _preview_input(state);
+    const ref = typeof provided['path'] === 'string' && provided['path'] !== ''
+        ? String(provided['path'])
+        : 'the provided artifact';
+    const lines: string[] = [
+        `> Input: ${preview}`,
+        `> \`${ref}\` is a finished design handed over as the spec, and no ` +
+            '`design-system.json` came with it. The design brief carries five ' +
+            'keys (layout, components, states, microcopy, a11y) — everything ' +
+            'below is outside them and would be rebuilt from taste rather than ' +
+            'read from your artifact:',
+    ];
+    for (const loss of UNCARRIED_BY_THE_BRIEF) {
+        lines.push(`> - ${loss}`);
+    }
+    lines.push(
+        '> 1. Proceed — port it with those five losses on the record; `apply` ' +
+            'still has to report what it honoured, translated, and flagged',
+        '> 2. Supply a `design-system.json` — its token values are then ' +
+            'honoured verbatim instead of re-derived',
+        '> 3. Abort — drop this UI request',
+        '',
+        '**Recommendation: 2 — Supply the contract** — it is the only option ' +
+            'that closes the spacing and easing losses at the source. Caveat: ' +
+            'pick 1 when no extractor is available; the port then proceeds with ' +
+            'the gap stated rather than hidden.',
+    );
+    return new StepResult({
+        outcome: Outcome.BLOCKED,
+        questions: lines,
+        message:
+            'UI design halted: a provided artifact carries no design-system.json; ' +
+            `${UNCARRIED_BY_THE_BRIEF.length} value class(es) cannot be carried by the brief.`,
+    });
+}
+
 /** Render a one-line preview of the input being designed. */
 function _preview_input(state: DeliveryState): string {
     const data = (_isDict(state.ticket) ? state.ticket : {}) as Record<string, Any>;

package/dist/agent-src/templates/scripts/work_engine/directives/ui/polish.ts

@@ -16,7 +16,7 @@ import {
     agent_directive,
 } from '../../delivery_state.js';
 import {
-    UNSUPPORTED_LANE,
+    is_ambiguous_stack,
     bundle_line,
     unsupported_stack_questions,
 } from './stack_bundles.js';
@@ -116,6 +116,41 @@ function _pyTruthy(value: Any): boolean {
     return true;
 }
 
+/**
+ * Findings the provided artifact already answers — informational, never
+ * fix-worthy.
+ *
+ * A port carries its source's aesthetic on purpose. Left unfiltered, a
+ * finding like "cream palette reads as scaffold-default" is indistinguishable
+ * from a real defect, so the polish loop spends a round editing the port away
+ * from the spec the user approved — the exact regression `daf-slop-vs-provided`
+ * witnesses. Marking the finding rather than deleting it keeps it visible in
+ * the review output; what changes is that it no longer drives a round.
+ *
+ * Scope is strict, and the burden sits with the marker: only a decision the
+ * artifact **actually covers** may carry the flag. Generative work in the same
+ * run is not artifact-covered and stays fully subject to the anti-slop scan.
+ */
+export const ARTIFACT_COVERED_KEY = 'artifact_covered';
+
+/** True when this finding is answered by the provided artifact. */
+function _is_artifact_covered(finding: Any): boolean {
+    return _isDict(finding) && finding[ARTIFACT_COVERED_KEY] === true;
+}
+
+/** Split findings into the ones that drive rounds and the informational rest. */
+export function partition_artifact_covered(findings: ReadonlyArray<Any>): {
+    actionable: Any[];
+    informational: Any[];
+} {
+    const actionable: Any[] = [];
+    const informational: Any[] = [];
+    for (const finding of findings) {
+        (_is_artifact_covered(finding) ? informational : actionable).push(finding);
+    }
+    return { actionable, informational };
+}
+
 /** Apply the polish-loop gate. */
 export function run(state: DeliveryState): StepResult {
     const review = _pyTruthy(state.ui_review) ? (state.ui_review as Record<string, Any>) : {};
@@ -125,6 +160,11 @@ export function run(state: DeliveryState): StepResult {
     }
     const review_clean = _pyTruthy(review['review_clean']);
 
+    // Artifact-covered findings are dropped from the round-driving set before
+    // anything else reads it — including the ceiling check, so a port cannot
+    // burn its two rounds on findings it was never allowed to act on.
+    findings = partition_artifact_covered(findings as Any[]).actionable;
+
     if (review_clean || (findings as Any[]).length === 0) {
         return new StepResult({ outcome: Outcome.SUCCESS });
     }
@@ -195,12 +235,15 @@ function _delegate_to_polish_skill(
     ceiling: number,
 ): StepResult {
     const directive = _resolve_directive(state);
-    const unsupported_label = _stack_label(state);
-    if (unsupported_label === UNSUPPORTED_LANE) {
+    if (is_ambiguous_stack(state.stack)) {
+        const conflicts = ((state.stack as Record<string, Any>)['ambiguity'] ??
+            []) as ReadonlyArray<string>;
         return new StepResult({
             outcome: Outcome.BLOCKED,
-            questions: unsupported_stack_questions('polish'),
-            message: 'UI polish refused: frontend framework not modelled by any lane.',
+            questions: unsupported_stack_questions('polish', conflicts),
+            message:
+                `UI polish halted: detection is ambiguous (${conflicts.join('; ')}) — ` +
+                'the open question is which project to build for.',
         });
     }
     const stack_label = _stack_label(state);
@@ -222,7 +265,7 @@ function _delegate_to_polish_skill(
         questions: [
             agent_directive(directive),
             `> Stack: \`${stack_label}\`. Polish round ${next_round} of ${ceiling}.`,
-            bundle_line(stack_label, 'build'),
+            bundle_line(state.stack, 'build', stack_label),
             findings_line,
             '> Fix chart-type / contrast findings against the adopted ' +
                 "corpus rows (design-intelligence § 'Grounding the " +

package/dist/agent-src/templates/scripts/work_engine/directives/ui/review.ts

@@ -17,7 +17,7 @@ import {
     agent_directive,
 } from '../../delivery_state.js';
 import {
-    UNSUPPORTED_LANE,
+    is_ambiguous_stack,
     bundle_line,
     unsupported_stack_questions,
 } from './stack_bundles.js';
@@ -192,11 +192,15 @@ function _stack_label(state: DeliveryState): string {
 function _delegate_to_review_skill(state: DeliveryState): StepResult {
     const directive = _resolve_directive(state);
     const stack_label = _stack_label(state);
-    if (stack_label === UNSUPPORTED_LANE) {
+    if (is_ambiguous_stack(state.stack)) {
+        const conflicts = ((state.stack as Record<string, Any>)['ambiguity'] ??
+            []) as ReadonlyArray<string>;
         return new StepResult({
             outcome: Outcome.BLOCKED,
-            questions: unsupported_stack_questions('review'),
-            message: 'UI review refused: frontend framework not modelled by any lane.',
+            questions: unsupported_stack_questions('review', conflicts),
+            message:
+                `UI review halted: detection is ambiguous (${conflicts.join('; ')}) — ` +
+                'the open question is which project to build for.',
         });
     }
     return new StepResult({
@@ -205,7 +209,7 @@ function _delegate_to_review_skill(state: DeliveryState): StepResult {
             agent_directive(directive),
             `> Stack: \`${stack_label}\`. Reviewing rendered components ` +
                 'against the locked design brief.',
-            bundle_line(stack_label, 'review'),
+            bundle_line(state.stack, 'review', stack_label),
             '> The review pass compares `state.ticket.ui_apply.rendered` ' +
                 'against `state.ui_design` (microcopy, states, a11y, layout) ' +
                 'and produces a structured `findings` list.',