@tenphi/akno-core 0.12.0 → 0.13.0

package/dist/ops/answer-record-rendering.js

@@ -0,0 +1,149 @@
+import { z } from 'zod';
+import { hasDeicticTime, hasSourceRelativeAnchor, hasUnknownReferenceClock, } from "../timeline/source-clock.js";
+/** A single bound record permits preservation without guessing its current language from old policy. */
+export function answerRecordRendering(evidence, frames, language, knowledgeLanguage = null) {
+    if (!language || evidence.length !== 1 || frames.size !== 1)
+        return undefined;
+    const item = evidence[0];
+    if (item.type !== 'page' ||
+        item.lines.length !== 1 ||
+        item.lines[0].memory?.status !== 'qualified' ||
+        !frames.has(item.evidence_id))
+        return undefined;
+    // Match the ordinary answer renderer's boundary trim before language and support verification.
+    // Visible qualification labels and all interior text remain exact.
+    const text = item.lines[0].text.replace(/^[-*] /u, '').trim();
+    if (!text.trim() || text.length > 600)
+        return undefined;
+    // Copying an embedded citation/link would let payload text impersonate server-owned citations.
+    // Leave reference-bearing records to the existing composition path, which selects their prose.
+    if (/\[|<(?:\/?[A-Za-z]|!)/u.test(text))
+        return undefined;
+    return {
+        evidence_id: item.evidence_id,
+        text,
+        // Policy does not prove the language of old bytes. This only removes a shortcut; a translation
+        // can preserve already-localized prose and still must pass actual language and source checks.
+        ...(knowledgeLanguage && language !== knowledgeLanguage ? { copy_allowed: false } : {}),
+        // Match the readable-clock obligation enforced downstream. A private frame or unknown
+        // metadata alone cannot authorize an extra source-clock statement in generated prose.
+        ...(language === 'ru' &&
+            item.lines[0].memory.temporal?.time.precision === 'unknown' &&
+            hasDeicticTime(text) &&
+            hasSourceRelativeAnchor(text) &&
+            hasUnknownReferenceClock(text)
+            ? { source_clock_translation: true }
+            : {}),
+    };
+}
+export function answerRecordBlockSchema(record) {
+    const evidence_ids = z.array(z.enum([record.evidence_id])).length(1);
+    const translation = record.source_clock_translation
+        ? z.strictObject({
+            rendering_mode: z.enum(['translate']),
+            translated_record: z.strictObject({
+                // These fields and two joining spaces share the previous 2,000-character text cap.
+                proposition_and_nontemporal_scope: z.string().trim().min(1).max(1_200),
+                source_clock_anchor: z.string().trim().min(1).max(400),
+                remaining_clock_qualifications: z.string().trim().min(1).max(398),
+            }),
+            evidence_ids,
+        })
+        : z.strictObject({
+            rendering_mode: z.enum(['translate']),
+            text: z.string().trim().min(1).max(2_000),
+            evidence_ids,
+        });
+    if (record.copy_allowed === false)
+        return translation;
+    // Ordinary anyOf, not a discriminated oneOf, is supported by the existing provider contract.
+    return z.union([
+        z.strictObject({
+            rendering_mode: z.enum(['copy']),
+            evidence_ids,
+        }),
+        translation,
+    ]);
+}
+/** Concatenation adds no semantic content; the exact result still needs language and source checks. */
+export function answerRecordText(block, record) {
+    if ('text' in block)
+        return block.text;
+    if ('translated_record' in block) {
+        const clauses = block.translated_record;
+        return [
+            clauses.proposition_and_nontemporal_scope,
+            clauses.source_clock_anchor,
+            clauses.remaining_clock_qualifications,
+        ].join(' ');
+    }
+    return record.text;
+}
+export const ANSWER_RECORD_RENDERING_CONTRACT = `When complete_record_rendering is supplied, select that
+single retained record only if it answers the question. Return at most one block. Choose rendering_mode
+translate when copy_allowed is false; the policy disables copying without classifying the stored bytes.
+Otherwise choose rendering_mode
+copy when its readable prose already uses output_language; return only that mode and evidence_ids,
+without a text field. The server will supply the exact current readable text. Otherwise
+choose translate and translate the COMPLETE retained text into output_language. Check the language of the COMPLETE current readable text, including visible status and attribution
+labels, not the query or private frame. Translate whenever any readable label needs localization.
+A Russian target with English retained prose requires translate, even when the source frame is Russian.
+The mode is a generation
+choice, not a trusted language classification; both copied and translated text undergo all existing checks.
+
+Preserve every retained clause, including the complete actor chain, personal limits, conditional
+consequences, negation and scope. Do not summarize, shorten, add an introduction, answer a presupposition
+from the question, or import a recording/action detail from the private original frame. The whole retained
+record is the rendering unit here; unrelated material in its private frame remains unavailable. The frame
+only constrains interpretation, including explicit bilingual clarification. A conflict requires withholding
+the block, not correcting or expanding the record. If it cannot answer the question, return no blocks.
+
+In translations, proper names keep their exact source spelling: do not transliterate them. After
+translating the surrounding prose, copy each required named_source_reference.exact_spelling verbatim
+into its source-supported role in the final text. Never introduce a name or role absent from the record. Translate
+ordinary vocabulary and generic role labels, including every part of a hyphenated component description.
+Translate the complete compound by its source meaning; do not leave an English fragment beside a
+translated noun. A technical test selects both an object and a tested property: naming only the object
+and generic soundness loses the specific test. Keep the source-stated property explicit in target-language
+prose. Do not add a property when the source only names an unspecified check or measurement.
+If translating a visible report heading, use that record's supplied report_source_display_phrase exactly
+for its outer attribution. Keep any other supported status labels localized. This phrase cannot replace
+the inner speaker or an embedded action's actor, and cannot add an unretained reporting or recording act.
+For nested reports, make the outer source and inner speaker
+unambiguous: use 'According to OUTER, INNER said ...' or 'По словам OUTER, INNER сообщил ...'. Do not swap
+their roles or rely on an ambiguous recipient/possessive construction with an indeclinable name. Render
+the supported meaning in full even when the question requests only part of that record.
+A bilingual restatement that fixes a term's referent controls its translation: render that same referent
+throughout, without inventing two components or alternative services from two source-language wordings.
+Do not specialize an unspecified measurement by choosing its measured property. Keep coverage arguments
+in their source roles: a covered repair is not a repair that covers the component. For an unresolved
+repair-coverage question in Russian, a nominal relation such as «вопрос о покрытии ремонта» followed
+by the component in the genitive case preserves the repair object. Preserve the record's actual nonresolution
+predicate and scope, and supply a coverer only when the selected source names one.
+
+When translating a retained counterfactual into Russian, render its actual selected antecedent with
+an explicit «если бы» conditional and its consequence with a subjunctive «бы». State the retained
+nonoccurrence and not-current limit in separate complete clauses. Preserve whose unrealized action
+conditions which consequence; do not replace the conditional with a nominal description of an alternative.
+When the record uses an unknown source clock, first translate its actor/action and actual interval.
+Then give separate complete clauses locating that interval relative to the original undated record
+(in Russian, make the interval the subject of «отсчитывается от времени первоначальной записи без даты»),
+contrasting it with processing time, and stating the unknown calendar date or period. Keep the actual
+direction and interval, and preserve any nonacceptance, no-event or proposal-only limits separately.
+Use these clauses only for qualifications already in the retained record; an ordinary dated statement
+must not acquire unknownness or a processing-time contrast. Do not derive a calendar date from today.
+
+When source_clock_translation is true and you select translate, return translated_record instead of text.
+Each segment is final public prose, not a plan or evidence. The server joins them with spaces in this order:
+- proposition_and_nontemporal_scope: translate the complete actor/action/object, its actual selected
+  interval, visible status labels, and every nonclock limit. Keep nonacceptance, no-event and proposal-only
+  limits when retained. A tentative-time label qualifies timing, not uncertainty about the proposal act.
+- source_clock_anchor: one standalone sentence with the selected interval as subject of
+  «отсчитывается от времени первоначальной записи без даты». Preserve the actual interval and direction;
+  do not state an unrelated example or quote the whole anchoring sentence.
+- remaining_clock_qualifications: translate the remaining retained clock restrictions, including
+  processing-time contrast and unknown recording/calendar time only when present. Do not invent a clock.
+End each segment with sentence punctuation. Together they must translate every clause of the complete
+retained record without importing a proposition from the query or private frame. Missing or conflicting
+support requires no block. The segment names supply no authority and cannot bypass any verification.`;
+//# sourceMappingURL=answer-record-rendering.js.map

package/dist/ops/answer-record-rendering.js.map

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

package/dist/ops/answer-source-audit.d.ts

@@ -0,0 +1,354 @@
+import { z } from 'zod';
+/** Force original interpretation before drafting, without reusing it as verification evidence. */
+export declare function answerReadingSchema(ids: readonly string[]): z.ZodArray<z.ZodObject<{
+    selected_meaning: z.ZodString;
+    clarification_or_ambiguity: z.ZodNullable<z.ZodString>;
+    evidence_id: z.ZodEnum<{
+        [x: string]: string;
+    }>;
+}, z.core.$strip>>;
+export interface AnswerAuditAnchor {
+    anchor_id: string;
+    text: string;
+}
+/** Coordinates only: preserve all bytes, including boundaries, without inferring propositions. */
+export declare function answerAuditAnchors(text: string, owner: string): AnswerAuditAnchor[];
+export interface AnswerAuditCoordinates {
+    sources: ReadonlyMap<string, readonly AnswerAuditAnchor[]>;
+    answer: readonly AnswerAuditAnchor[];
+}
+/** Categories prevent an easy object comparison from replacing the separate action-actor audit. */
+export declare function answerAlignmentSchema(coordinates: AnswerAuditCoordinates): z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    object_and_operation: z.ZodUnion<readonly [z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodNull;
+        source_specifics: z.ZodString;
+        answer_specifics: z.ZodNull;
+        relation: z.ZodEnum<{
+            not_selected: "not_selected";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodNull;
+        answer_anchor: z.ZodNull;
+        source_specifics: z.ZodNull;
+        answer_specifics: z.ZodNull;
+        relation: z.ZodEnum<{
+            not_selected: "not_selected";
+        }>;
+    }, z.core.$strict>]>;
+    tested_property: z.ZodObject<{
+        source_anchor: z.ZodNull;
+        answer_anchor: z.ZodNull;
+        source_property: z.ZodNull;
+        answer_property: z.ZodNull;
+        relation: z.ZodEnum<{
+            not_selected: "not_selected";
+        }>;
+    }, z.core.$strict>;
+    qualification: z.ZodUnion<readonly [z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            preserved: "preserved";
+            generalized: "generalized";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            omitted: "omitted";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodNullable<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            not_selected: "not_selected";
+        }>;
+    }, z.core.$strict>]>;
+    evidence_id: z.ZodEnum<{
+        [x: string]: string;
+    }>;
+    source_context: z.ZodString;
+    actor: z.ZodUnion<readonly [z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            preserved: "preserved";
+            generalized: "generalized";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            omitted: "omitted";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodNullable<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            not_selected: "not_selected";
+        }>;
+    }, z.core.$strict>]>;
+}, z.core.$strict>, z.ZodObject<{
+    object_and_operation: z.ZodUnion<readonly [z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        source_specifics: z.ZodString;
+        answer_specifics: z.ZodString;
+        relation: z.ZodEnum<{
+            preserved: "preserved";
+            generalized: "generalized";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodNull;
+        source_specifics: z.ZodString;
+        answer_specifics: z.ZodNull;
+        relation: z.ZodEnum<{
+            omitted: "omitted";
+        }>;
+    }, z.core.$strict>]>;
+    tested_property: z.ZodUnion<readonly [z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        source_property: z.ZodString;
+        answer_property: z.ZodString;
+        relation: z.ZodEnum<{
+            preserved: "preserved";
+            generalized: "generalized";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodNull;
+        source_property: z.ZodString;
+        answer_property: z.ZodNull;
+        relation: z.ZodEnum<{
+            omitted: "omitted";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodNull;
+        answer_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        source_property: z.ZodNull;
+        answer_property: z.ZodString;
+        relation: z.ZodEnum<{
+            changed: "changed";
+        }>;
+    }, z.core.$strict>]>;
+    qualification: z.ZodUnion<readonly [z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            preserved: "preserved";
+            generalized: "generalized";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            omitted: "omitted";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodNullable<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            not_selected: "not_selected";
+        }>;
+    }, z.core.$strict>]>;
+    evidence_id: z.ZodEnum<{
+        [x: string]: string;
+    }>;
+    source_context: z.ZodString;
+    actor: z.ZodUnion<readonly [z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            preserved: "preserved";
+            generalized: "generalized";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            omitted: "omitted";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodNullable<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            not_selected: "not_selected";
+        }>;
+    }, z.core.$strict>]>;
+}, z.core.$strict>, z.ZodObject<{
+    object_and_operation: z.ZodUnion<readonly [z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        source_specifics: z.ZodString;
+        answer_specifics: z.ZodString;
+        relation: z.ZodEnum<{
+            preserved: "preserved";
+            generalized: "generalized";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodNull;
+        source_specifics: z.ZodString;
+        answer_specifics: z.ZodNull;
+        relation: z.ZodEnum<{
+            omitted: "omitted";
+        }>;
+    }, z.core.$strict>]>;
+    tested_property: z.ZodObject<{
+        source_anchor: z.ZodNull;
+        answer_anchor: z.ZodNull;
+        source_property: z.ZodNull;
+        answer_property: z.ZodNull;
+        relation: z.ZodEnum<{
+            absent_from_both: "absent_from_both";
+        }>;
+    }, z.core.$strict>;
+    qualification: z.ZodUnion<readonly [z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            preserved: "preserved";
+            generalized: "generalized";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            omitted: "omitted";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodNullable<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            not_selected: "not_selected";
+        }>;
+    }, z.core.$strict>]>;
+    evidence_id: z.ZodEnum<{
+        [x: string]: string;
+    }>;
+    source_context: z.ZodString;
+    actor: z.ZodUnion<readonly [z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            preserved: "preserved";
+            generalized: "generalized";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            omitted: "omitted";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source_anchor: z.ZodNullable<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+        answer_anchor: z.ZodNull;
+        detail: z.ZodString;
+        relation: z.ZodEnum<{
+            not_selected: "not_selected";
+        }>;
+    }, z.core.$strict>]>;
+}, z.core.$strict>]>>;
+export declare function answerAlignmentsSupported(value: unknown, coordinates: AnswerAuditCoordinates): boolean;
+export declare const ANSWER_READING_CONTRACT = "When record_readings is required, fill it BEFORE drafting blocks.\nReturn exactly one reading per evidence_id with a non-null retention_source_frame. First identify only\nthe proposition selected by the readable retained excerpt. Then read its complete original frame to\nconstrain that selected meaning, including explicit cross-language clarification, actors and scope.\nUse selected_meaning as a terse source-wording role plan, within 320 characters: operation, its object,\nsource-specified tested property or mechanism, and material modifiers. Keep the material source\nexpressions as exact quotations in their supplied language; do not translate or merge them into a\nbroader target-language term here. No configured or presumed language overrides the current source\nbytes. Explicit source clarification can identify the controlling expression across languages.\nFor coverage, distinguish the covered item/service from its coverer; leave an unspecified coverer\nunspecified. Put material roles and scope first, without narrative padding or a term dictionary.\nIn clarification_or_ambiguity (at most 240 characters), identify an actual frame clarification or\nambiguity, or a material neighboring frame proposition EXCLUDED by this excerpt's selection; otherwise\nuse null. An excluded neighboring act is not a clarification that can be added to the selected record.\nThese private fields may quote source-language prose regardless of output_language. Translate ordinary\nvocabulary only when drafting the public block; keep exact names/identifiers and all selected meaning.\nOnly the source can establish equivalence; query wording and adjacent independent propositions cannot.\nKeep each reading local to its evidence_id: a shared original frame does not merge separately retained\npropositions into one citable record. If a block states a second record's selected proposition, include\nthat record's evidence_id. A fictional promise alone may cite its promise record; adding an actual\nproposal to discuss it requires the proposal record too. Neutral source provenance is not that act.\nResolve source-explicit clarification before deciding whether a conflict remains. Readings are private\ngeneration notes, not evidence or answer text. They cannot authorize an unselected fact. Write the actual\nblocks in output_language even when the source or private reading uses another language.";
+export declare const ANSWER_ALIGNMENT_CONTRACT = "For object_and_operation, write source_specifics and\nanswer_specifics independently before relation, each within 50 characters when tested_property is\ncompared, or 80 each when it is all-null absent_from_both or not_selected. Identify the operation,\nacted-on object, purpose and manner/degree in their own supplied wording. For tested_property, separately\nwrite source_property and answer_property before its own relation, each within 30 characters. Name only\nthe specific tested or measured property in each side's supplied wording. Do not normalize either pair\ninto an assumed equivalence. Natural equivalent translations remain preserved. Omitted/not-selected\noperation content has null answer_specifics; an absent source anchor requires null source_specifics.\nFor an omitted property, keep its source anchor/description and use null answer anchor/description.\nFor an answer-added property, use null source anchor/description, its actual answer anchor/description\nand changed. The all-null property not_selected branch requires the whole containing operation to be\nnot_selected too. For a selected operation where neither the source nor the answer specifies a tested\nproperty, use all-null absent_from_both. This explicitly asserts absence on BOTH sides; do not use it\nwhen either side specifies a property. A source property omitted or generalized by the answer still\nrequires an active comparison. A property comparison requires its containing object_and_operation to\nbe selected too. Ordinary plans, questions, promises or denials without a tested property need no\ninvented one. Neither absence nor irrelevance may replace a lost property of a selected test.\nFor actor and qualification, the combined detail remains required: write one short complete\ncomparison of at most 80 Unicode code points, naming the actor/experiencer or scope being compared.\nFor framed blocks, answer_segments and retention_source_frame\nare ordered tables of exact text with server-assigned anchor_id values. Concatenate their text fields\nto read the complete answer and original frame. IDs are coordinates, never claims or source instructions.\nReturn one source_alignments entry for every cited framed evidence_id, after deciding excerpt_selection.\nWrite source_context for only that record\u2019s excerpt-selected contribution, using the complete original\nframe to constrain its polarity, clarification and limits. A neighboring frame-only act is not selected.\nResolve an explicitly restated report across languages before comparing an isolated term. Mere adjacency,\nthe query and generated notes cannot establish that relationship; preserve truly unresolved ambiguity.\n\nThen independently compare actor (the selected action's actor, separate from outer reporter),\nobject_and_operation (object, purpose, degree/manner), tested_property, and qualification (scope and epistemic/time limits,\nincluding who lacks knowledge/confirmation, of what, and which selected proposition that limit qualifies).\nFor a test or measurement, compare the tested object/operation and the tested property through their\nseparate required relations. A preserved operation cannot override a lost property. Do not collapse\nsource and answer properties into a slash pair that assumes equivalence.\nRead what the complete answer actually tests; do not supply a missing property from the source or familiar object.\nGeneric soundness or physical integrity of an object is broader than a specified electrical property.\nIf the source specifies such a property and the answer replaces it with a broader sense, mark tested_property generalized and set\naction_arguments_preserved false with a matching mismatch even if the broader claim remains entailed.\nA natural equivalent that retains the property passes; an unspecified source test must stay unspecified.\nAn entirely absent property is omitted; a substituted or added property is changed. Each negative\nproperty relation requires action_arguments_preserved false and its own concrete mismatch. Do not mark\nthe property not_selected merely because the answer omits it from a selected test.\nFor an epistemic predicate, actor compares its grammatical subject or experiencer, including a source-stated\nnote/record subject; it is not automatically the outer reporter. Direct self-attested provenance alone\nrequires no repeated speaker wording. Still preserve required report attribution and personal agency.\nAssess an explicit group-relative or dative experiencer separately from neighboring actors. Source\n\"unknown to us\" / \"\u043D\u0430\u043C \u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\" is equivalent to \"we do not know\" / \"\u043C\u044B \u043D\u0435 \u0437\u043D\u0430\u0435\u043C\", not bare\n\"unknown\" / \"\u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\". A nearby person introducing a hypothesis or reporting no actual event\ndoes not supply the missing group. For a selected group-relative limit changed to bare unknownness,\nactor is omitted with the original epistemic source anchor and answer_anchor null; qualification is\ngeneralized or changed at the actual bare-unknownness answer anchor. Set action_arguments_preserved\nand qualification_scope_preserved false with separate mismatches; the stronger unqualified claim also\nfails proposition_supported. A substituted explicit experiencer uses changed with its actual answer\nanchor. Do not mark every actor preserved merely because one neighboring actor survives. Apply this\nonly to the selected epistemic limit: an independent private-frame clause stays unselected, and source\nunknownness that is genuinely impersonal requires no invented group.\nCompare every material selected limit against its actual answer counterpart; matching uncertainty words\ncannot preserve a changed verification object. Source_context describes only the original source;\ncomparison detail must retain any specification added by the answer instead of silently correcting it.\nSelect source_anchor from that evidence's original frame and answer_anchor from this current block.\nNever invent an ID or substitute a retained paraphrase for an original. An anchor only locates the\nselected aspect. Judge its meaning against the COMPLETE frame and block: content elsewhere in this same\nblock can preserve a role or modifier missing from a short anchor. Other blocks cannot supply it.\nFor a block citing several records, compare each record's selected contribution separately. When the\nsource explicitly identifies the same example or event, a second cited record can describe its content\nwithout changing or generalizing the first record's object. Do not require each record to supply every\ndetail of that shared clause. Generalized requires an actual lost restriction from this record's selected\nmeaning, not merely additional detail supported by another citation. Shared topic alone cannot establish\nthat the records describe the same thing; all contributed content must still pass excerpt selection.\nEvery material restriction belonging to this record's contribution remains required. Sibling evidence\ncannot hide its loss or turn a generalized, changed or omitted contribution into preserved or not_selected.\n\nUse preserved for equivalent meaning, including natural technical paraphrase. Use generalized for a\nmaterial restriction lost from the complete block, changed for a different actor/object/scope, or omitted\nwhen a required selected counterpart has no answer counterpart (answer_anchor null). These three\nnegative relations require concrete differences in the comparison descriptions and the corresponding semantic mismatch.\nFor omitted, answer_anchor MUST be null; an anchor locating nearby text is not a missing counterpart.\nFor a present but changed or generalized counterpart, use that relation and its actual answer anchor.\nAn actor loss requires action_arguments_preserved false and its own mismatch; a lost or changed epistemic\nlimit requires qualification_scope_preserved false and its own mismatch. Assess proposition_supported\nseparately and give a mismatch for it too if false. Never pair a negative alignment with all-positive\ndimensions or place every defect solely under qualification regardless of which dimension it affects.\nFor an incidental actor, operation or qualification not selected or asserted in this block, use not_selected and answer_anchor\nnull; source_anchor may be null only if no applicable source content exists. A sentence/anchor is not\nan indivisible proposition: independent neighboring details need not appear. Complete-record rendering\nrequires the entire RETAINED record, not every proposition in the private frame. If the retained record\nidentifies a person's question without retaining their separate recording act, do not require that act\nor label its absence an omitted actor. The selected question owner must still be preserved. Every cited record must\ncontribute at least one selected category; all four cannot be not_selected.\n\nDo not mark a named proposer not_selected when describing that proposal. An outer reporter is not its\nproposer, and a generic fault does not preserve a specific mechanism. Source_context and comparisons\nare fallible notes; membership alone proves no semantics. Every existing semantic dimension and\nindependent retained-excerpt selection remain mandatory. A negative relation/verdict cannot be overridden.";
+//# sourceMappingURL=answer-source-audit.d.ts.map

package/dist/ops/answer-source-audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answer-source-audit.d.ts","sourceRoot":"","sources":["../../src/ops/answer-source-audit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,kGAAkG;AAClG,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE;;;;;;mBAKzD;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,kGAAkG;AAClG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAqBnF;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC,CAAC;IAC3D,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACtC;AA+HD,mGAAmG;AACnG,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA+CxE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,sBAAsB,GAAG,OAAO,CAetG;AAED,eAAO,MAAM,uBAAuB,g2EAuBqD,CAAC;AAE1F,eAAO,MAAM,yBAAyB,4uSA6FqE,CAAC"}