create-principles-disciple 1.145.43 → 1.146.1

package/console/lab/lib/challenge-actor.mjs

@@ -0,0 +1,394 @@
+// SPEC-PD-EXAMINER-001 v0.3 — Phase 1B ActorTraceV1 + controlled Actor Loop
+// for challenge studies (offline stub mode only).
+//
+// Route per SPEC §2.1: existing runRealActorOpportunity() is welded to the
+// PLE-PILOT-01 oracle (imports newRunState/step/outcome from oracle.mjs), so
+// this is an INDEPENDENT Challenge Loop that reuses the verified disciplines
+// instead of performing coupling surgery on the frozen G2 actor:
+//   - fixed JSON action protocol + structural validation before any effect;
+//   - bounded loop with maxSteps / maxInvalidActions (actor.mjs caps pattern);
+//   - narrative text carried verbatim but NEVER used as evidence (oracle.mjs
+//     discipline);
+//   - actor self-report is never an observation (evaluator.mjs discipline).
+//
+// The actor VIEW strips judge-side fields (implies maps) — the trace contains
+// only what an actor could legitimately see. Gold lives in judge-only files;
+// the gold-informed stub is explicitly labeled as a pipeline-wiring fixture,
+// never as an arm measurement.
+
+import { buildClaimEnvironment, newClaimRunState, stepClaimEnvironment } from './claim-evidence-env.mjs';
+import { hashOfCanonical, sha256 } from './challenge-freeze.mjs';
+
+export const ACTOR_TRACE_SCHEMA = 'actor-trace.v1';
+export const ACTOR_RUN_STATUS_VALUES = ['COMPLETED', 'FAILED', 'NO_RESPONSE', 'INTERRUPTED', 'UNKNOWN'];
+
+export const OFFLINE_RUNTIME_ID = 'offline-scripted-runtime-v1';
+export const RUNTIME_RECEIPT_SCHEMA = 'offline-runtime-prompt-receipt.v1';
+
+/**
+ * The offline RUNTIME's own record that it was handed a prompt. Generated by
+ * the runtime from the exact string it received — the runner cannot author it
+ * on the actor's behalf, and the recorded hash is of what the runtime actually
+ * loaded, not of what the runner intended to send. A unit whose runtime never
+ * produced a receipt proves nothing above SELECTED.
+ */
+export function buildOfflineRuntimeReceipt(armPrompt, runtimeId = OFFLINE_RUNTIME_ID) {
+  if (typeof armPrompt !== 'string' || armPrompt.length === 0) {
+    throw new Error('buildOfflineRuntimeReceipt: the runtime must be handed a non-empty prompt string');
+  }
+  const core = {
+    schema: RUNTIME_RECEIPT_SCHEMA,
+    runtimeId,
+    receivedPromptHash: sha256(armPrompt),
+    receivedChars: armPrompt.length,
+    loaded: true,
+  };
+  return { ...core, receiptHash: hashOfCanonical(core) };
+}
+
+export function verifyOfflineRuntimeReceipt(receipt) {
+  if (!receipt || receipt.receiptHash === undefined) return { ok: false, problems: ['no runtime receipt supplied'] };
+  const { receiptHash, ...core } = receipt;
+  const problems = [];
+  if (!/^[a-f0-9]{64}$/.test(String(receiptHash)) || hashOfCanonical(core) !== receiptHash) {
+    problems.push('receiptHash mismatch — the runtime receipt was modified after generation');
+  }
+  if (receipt.schema !== RUNTIME_RECEIPT_SCHEMA) problems.push(`receipt schema '${String(receipt.schema)}' unsupported`);
+  if (receipt.loaded !== true) problems.push('receipt does not record a completed load');
+  if (!/^[a-f0-9]{64}$/.test(String(receipt.receivedPromptHash))) problems.push('receipt carries no received prompt hash');
+  return { ok: problems.length === 0, problems };
+}
+
+
+export const DEFAULT_CHALLENGE_ACTOR_CAPS = {
+  maxSteps: 40,
+  maxInvalidActions: 2,
+};
+
+/** Thrown by stub actors to simulate a hard process crash mid-run: the
+ *  runner must NOT write any attempt result, leaving PREPARED-without-RESULT
+ *  (RESULT_UNKNOWN on recovery). */
+export class SimulatedCrashError extends Error {
+  constructor(atStep) {
+    super(`simulated crash at step ${atStep} (process died before result persistence)`);
+    this.name = 'SimulatedCrashError';
+    this.atStep = atStep;
+  }
+}
+
+function actorView(caseVisible, runState) {
+  return {
+    caseVisible,
+    constraints: caseVisible.constraints,
+    executedObservations: runState.executedObservations.map((r) => ({
+      obsId: r.obsId,
+      status: r.status,
+      source: r.source,
+      output: r.output,
+      costUnits: r.costUnits,
+      timeUnits: r.timeUnits,
+      ...(r.eventId ? { eventId: r.eventId, subjectId: r.subjectId, ...(r.requestId ? { requestId: r.requestId } : {}) } : {}),
+      // implies deliberately stripped — judge-side information
+    })),
+    budgetUsed: runState.budgetUsed,
+    timeUsed: runState.timeUsed,
+    deadlineBreached: runState.deadlineBreached,
+    signOffReceived: runState.signOffReceived,
+    taskCompleted: runState.taskCompleted,
+    step: runState.step,
+  };
+}
+
+/**
+ * Drive one case with an actor. Deterministic for stub actors: same env +
+ * same actor behavior → same trace. Every action, observation, budget
+ * refusal, invalid action and the termination reason are recorded with a
+ * strict sequence. The loop is ASYNC (real F1/F2 actors answer across real
+ * transports via challenge-actor-transport.mjs); offline stubs return
+ * synchronously and are awaited transparently — their traces are unchanged.
+ * `reserveRequest` (real-mode runs only) reserves one model-request ledger
+ * slot BEFORE each actor step; a refused reservation terminates the loop
+ * WITHOUT invoking the actor — the request is never sent. Stub runs pass no
+ * hook and are byte-identical to Phase 1B.
+ */
+export async function runControlledActorLoop({ env, runState, caseVisible, actor, linkage, caps = DEFAULT_CHALLENGE_ACTOR_CAPS, reserveRequest = null, runtimeReceipt = null }) {
+  if (!actor || typeof actor.nextAction !== 'function') throw new Error('runControlledActorLoop: actor.nextAction required');
+  const trace = {
+    schema: ACTOR_TRACE_SCHEMA,
+    actorKind: actor.kind || 'unknown-stub',
+    linkage,
+    // P1-2: the RUNTIME's own prompt-load receipt travels with the trace, so
+    // the attempt record itself carries the receipt hash the evidence chain
+    // must match. Absent when the actor is not prompt-aware (legacy stubs) —
+    // in that case no level above SELECTED may ever be claimed.
+    ...(runtimeReceipt ? { runtimeReceipt } : {}),
+    records: [],
+    finalReport: null,
+    usage: null,
+    termination: null,
+    narrativePolicy: 'actions may carry a narrative field; it is carried verbatim and NEVER used as observation evidence or score input',
+  };
+  let seq = 0;
+  const rec = (entry) => { entry.seq = seq++; trace.records.push(entry); };
+
+  let invalidActions = 0;
+  let done = false;
+  while (!done) {
+    if (runState.step >= caps.maxSteps) {
+      rec({ kind: 'termination', reason: 'step_cap', detail: `reached maxSteps=${caps.maxSteps} without a report` });
+      trace.termination = { reason: 'step_cap', actorRunStatus: 'NO_RESPONSE' };
+      break;
+    }
+    if (reserveRequest) {
+      const reservation = reserveRequest(runState.step);
+      if (!reservation || reservation.ok !== true) {
+        rec({ kind: 'termination', reason: 'request_budget_exhausted', detail: (reservation && reservation.reason) || 'model-request budget exhausted before dispatch — the request was NOT sent' });
+        trace.termination = { reason: 'request_budget_exhausted', actorRunStatus: 'NO_RESPONSE' };
+        break;
+      }
+    }
+    const action = await actor.nextAction(actorView(caseVisible, runState));
+    if (action && typeof action.narrative === 'string') rec({ kind: 'narrative_carried', text: action.narrative });
+    rec({ kind: 'action', action: { type: action && action.type, args: action && action.args } });
+    const result = stepClaimEnvironment(env, runState, action);
+    if (!result.ok) {
+      invalidActions += 1;
+      rec({ kind: 'invalid_action', error: result.error });
+      if (invalidActions >= caps.maxInvalidActions) {
+        rec({ kind: 'termination', reason: 'invalid_action_cap', detail: `${invalidActions} invalid actions` });
+        trace.termination = { reason: 'invalid_action_cap', actorRunStatus: 'FAILED' };
+        done = true;
+      }
+      continue;
+    }
+    if (result.record && result.record.status === 'refused_budget') {
+      rec({ kind: 'budget_event', event: 'observation_refused_budget', obsId: result.record.obsId, output: result.record.output });
+      continue;
+    }
+    if (action.type === 'report') {
+      trace.finalReport = runState.report;
+      rec({ kind: 'termination', reason: 'report_submitted', detail: 'actor submitted final claims' });
+      trace.termination = { reason: 'report_submitted', actorRunStatus: 'COMPLETED' };
+      done = true;
+      continue;
+    }
+    if (action.type === 'deploy') {
+      rec({ kind: 'consequence', event: 'deploy', authorizationViolated: runState.authorizationViolated, taskCompleted: runState.taskCompleted });
+      continue;
+    }
+    if (env.contractVersion >= 2 && ['refuse', 'block-path'].includes(action.type)) {
+      rec({ kind: 'behavior_event', event: action.type, args: action.args });
+      continue;
+    }
+    rec({ kind: 'observation', obsId: result.record.obsId, source: result.record.source, status: result.record.status, output: result.record.output,
+      ...(env.contractVersion >= 2 ? { eventId: result.record.eventId, ...(result.record.requestId ? { requestId: result.record.requestId, requestHash: result.record.requestHash } : {}) } : {}) });
+  }
+
+  trace.usage = {
+    steps: runState.step,
+    invalidActions,
+    observationsExecuted: runState.executedObservations.filter((r) => r.status === 'ok').length,
+    budgetRefusals: runState.refusedCount,
+    budgetUsed: runState.budgetUsed,
+    timeUnits: runState.timeUsed,
+  };
+  return { trace, runState };
+}
+
+// ---------------------------------------------------------------------------
+// Deterministic stub actors (offline wiring fixtures — never arm measurements)
+// ---------------------------------------------------------------------------
+
+/**
+ * Plays a fixed script; fails with SimulatedCrashError at `crashAt` if set.
+ *
+ * P1-2: the stub IS the offline runtime. It is handed the composed arm prompt
+ * (either at construction via `armPrompt` or later via `loadArmPrompt`) and
+ * answers with a receipt it computes itself from the exact string it received.
+ * Evidence above SELECTED can only come from that receipt.
+ */
+export function createScriptedStub({ kind = 'stub-scripted', actions = [], crashAt = null, armPrompt = null }) {
+  let i = 0;
+  let receipt = null;
+  const loadArmPrompt = (prompt) => {
+    const next = buildOfflineRuntimeReceipt(prompt);
+    if (receipt !== null) {
+      if (receipt.receivedPromptHash !== next.receivedPromptHash) {
+        throw new Error('offline runtime was handed a DIFFERENT prompt after loading — one arm prompt per unit');
+      }
+      return receipt;
+    }
+    receipt = next;
+    return receipt;
+  };
+  if (armPrompt !== null) loadArmPrompt(armPrompt);
+  return {
+    kind,
+    offlineStub: true,
+    loadArmPrompt,
+    get runtimeReceipt() { return receipt; },
+    nextAction(view) {
+      if (crashAt !== null && view.step >= crashAt) throw new SimulatedCrashError(view.step);
+      if (i >= actions.length) return { type: 'report', args: { claims: [] } }; // defensive; env rejects empty
+      return actions[i++];
+    },
+  };
+}
+
+/** Deterministic perfect-play script computed from caseDef (judge-only gold).
+ *  PIPELINE WIRING FIXTURE ONLY — proves plumbing, never behavior. The
+ *  executable actor is perfectPlayActor(); owner-answer evidence refs are
+ *  resolved against real OBS-OWNER-<step> ids during execution. */
+export function perfectPlayScript(caseDef) {
+  const actions = [];
+  const report = [];
+  const constraints = caseDef.constraints || {};
+  const budget = Number.isFinite(constraints.budgetUnits) ? constraints.budgetUnits : 99;
+  const deadline = Number.isFinite(constraints.deadlineUnits) ? constraints.deadlineUnits : 99;
+  let budgetUsed = 0;
+  let timeUsed = 0;
+  const executedIds = new Set(caseDef.preSeededObservations || []);
+
+  const tryObserve = (obs) => {
+    if (executedIds.has(obs.obsId)) return { obsId: obs.obsId, already: true };
+    if (budgetUsed + obs.costUnits > budget) return null;
+    if (timeUsed + obs.timeUnits > deadline) return null;
+    actions.push({ type: 'observe', args: { obsId: obs.obsId } });
+    budgetUsed += obs.costUnits;
+    timeUsed += obs.timeUnits;
+    executedIds.add(obs.obsId);
+    return { obsId: obs.obsId };
+  };
+  const tryAskOwner = (requestType, cost = 2, time = 1) => {
+    if (budgetUsed + cost > budget || timeUsed + time > deadline) return null;
+    actions.push({ type: 'ask-owner', args: { requestType } });
+    budgetUsed += cost;
+    timeUsed += time;
+    return { obsId: 'owner' };
+  };
+
+  if (caseDef.extraActions && caseDef.extraActions.deploy) {
+    tryAskOwner('deployment-signoff');
+  }
+
+  for (const required of caseDef.gold.requiredClaims) {
+    const wanted = required.acceptableVerdicts.find((v) => v === 'verified_true' || v === 'verified_false');
+    if (wanted) {
+      const target = wanted === 'verified_true' ? 'true' : 'false';
+      const candidates = [];
+      for (const obs of caseDef.observations || []) {
+        if (obs.implies && obs.implies[required.factId] === target) candidates.push({ obs, cost: obs.costUnits, via: 'observe' });
+      }
+      for (const [requestType, answer] of Object.entries(caseDef.ownerAnswers || {})) {
+        if (answer.implies && answer.implies[required.factId] === target) candidates.push({ obs: { obsId: `owner:${requestType}`, requestType, costUnits: 2, timeUnits: 1 }, cost: 2, via: 'ask-owner' });
+      }
+      candidates.sort((a, b) => a.cost - b.cost || String(a.obs.obsId).localeCompare(String(b.obs.obsId)));
+      for (const cand of candidates) {
+        const done = cand.via === 'observe' ? tryObserve(cand.obs) : tryAskOwner(cand.obs.requestType);
+        if (done) {
+          const evidenceRef = cand.via === 'observe' ? cand.obs.obsId : `OBS-OWNER-PENDING`; // resolved below
+          report.push({ factId: required.factId, verdict: wanted, evidenceRef });
+          break;
+        }
+      }
+    }
+  }
+
+  if (caseDef.extraActions && caseDef.extraActions.deploy) actions.push({ type: 'deploy' });
+
+  // Resolve owner-evidence refs: the loop assigns OBS-OWNER-<step>; predict deterministically.
+  let ownerSeq = 0;
+  for (const r of report) {
+    if (r.evidenceRef === 'OBS-OWNER-PENDING') r.evidenceRef = `OBS-OWNER-RESOLVED-${++ownerSeq}`;
+  }
+
+  for (const required of caseDef.gold.requiredClaims) {
+    if (report.some((r) => r.factId === required.factId)) continue;
+    report.push({ factId: required.factId, verdict: 'inferred', minimalSteps: 'stub-minimal-step: 执行该事实的对应观察后可升级为 verified' });
+  }
+
+  actions.push({ type: 'report', args: { claims: report } });
+  return actions;
+}
+
+/** Scripted wrapper so perfectPlayScript can be replayed step by step. */
+export function perfectPlayActor(caseDef) {
+  const script = perfectPlayScript(caseDef);
+  let i = 0;
+  // Owner evidence refs are assigned by the environment as OBS-OWNER-<step>;
+  // rewrite the predicted placeholders with the real ids while executing.
+  const ownerIds = [];
+  return {
+    kind: 'stub-perfect-play(gold-informed-pipeline-fixture)',
+    nextAction(view) {
+      const action = script[i++];
+      if (!action) return { type: 'report', args: { claims: [] } };
+      if (action.type === 'ask-owner') {
+        const step = view.step + 1; // the env assigns step before executing
+        const obsId = `OBS-OWNER-${step}`;
+        ownerIds.push(obsId);
+        return action;
+      }
+      if (action.type === 'report') {
+        const claims = action.args.claims.map((c) => {
+          if (typeof c.evidenceRef === 'string' && c.evidenceRef.startsWith('OBS-OWNER-RESOLVED-')) {
+            const idx = Number(c.evidenceRef.split('-').pop()) - 1;
+            return { ...c, evidenceRef: ownerIds[idx] || c.evidenceRef };
+          }
+          return c;
+        });
+        return { type: 'report', args: { claims } };
+      }
+      return action;
+    },
+  };
+}
+
+/** Observes everything affordable in listed order, then reports every fact as
+ *  inferred with minimal steps — never fabricates a verdict direction. Shows
+ *  abstention detection on required-verifiable claims. */
+export function createGreedyObserverStub() {
+  return {
+    kind: 'stub-greedy-observer',
+    nextAction(view) {
+      const { caseVisible, executedObservations, budgetUsed, timeUsed } = view;
+      const { budgetUnits, deadlineUnits } = caseVisible.constraints;
+      const doneIds = new Set(executedObservations.map((r) => r.obsId));
+      for (const obs of caseVisible.availableObservations) {
+        if (doneIds.has(obs.obsId)) continue;
+        if (budgetUsed + obs.costUnits <= budgetUnits && timeUsed + obs.timeUnits <= deadlineUnits) {
+          return { type: 'observe', args: { obsId: obs.obsId } };
+        }
+      }
+      return {
+        type: 'report',
+        args: {
+          claims: caseVisible.facts.map((f) => ({ factId: f.factId, verdict: 'inferred', minimalSteps: 'stub-greedy: 未断言方向，需语义判读' })),
+        },
+      };
+    },
+  };
+}
+
+/** Runs exactly one observation (the first listed), then asserts verified_true
+ *  citing it for every fact — the classic surface-compliance failure shape. */
+export function createNaiveStub() {
+  let observed = false;
+  let firstObsId = null;
+  return {
+    kind: 'stub-naive-surface-compliance',
+    nextAction(view) {
+      if (!observed) {
+        firstObsId = view.caseVisible.availableObservations[0].obsId;
+        observed = true;
+        return { type: 'observe', args: { obsId: firstObsId } };
+      }
+      return {
+        type: 'report',
+        args: { claims: view.caseVisible.facts.map((f) => ({ factId: f.factId, verdict: 'verified_true', evidenceRef: firstObsId })) },
+      };
+    },
+  };
+}
+
+export { buildClaimEnvironment, newClaimRunState };

package/console/lab/lib/challenge-arms.mjs

@@ -0,0 +1,102 @@
+// SPEC-PD-EXAMINER-001 v0.3 — Phase 1A immutable A/B/Summary arm configuration
+// for challenge studies. Reuses the G2 single delivery path (deliverPayload:
+// research-same-channel-v1, payloadHash = sha256(payload bytes), over-budget
+// throws — never truncates) and the PRI-971 freeze interface (freezeCandidate).
+// Content modes reuse the real-runner vocabulary: A='none', B='policy',
+// C='summary'. This module only BUILDS and AUDITS configurations — it never
+// transports anything and never opens a socket. Real runs stay NOT_RUN.
+
+import { deliverPayload, composeActorPrompt } from './g2.mjs';
+import { freezeCandidate } from './sidecar.mjs';
+import { sha256 } from './fixture.mjs';
+
+export const CHALLENGE_ARM_IDS = ['A', 'B', 'C'];
+
+/**
+ * Build the three frozen arm configs. The B payload is the EXACT frozen
+ * principle statement (SPEC §6.2.6: prefer the production-deliverable
+ * principleDraft.statement) — payloadHash must equal statementSha256 from the
+ * frozen principle asset. The C payload is an experience summary that shares
+ * the underlying incident but must NOT contain the principle's normative
+ * expression (checked by auditArmIsolation).
+ */
+export function buildStudyArms({ commonContextText, principleStatement, summaryText, budgetChars = 2000 }) {
+  if (typeof commonContextText !== 'string' || commonContextText.length === 0) throw new Error('buildStudyArms: commonContextText required');
+  if (typeof principleStatement !== 'string' || principleStatement.length === 0) throw new Error('buildStudyArms: principleStatement required');
+  if (typeof summaryText !== 'string' || summaryText.length === 0) throw new Error('buildStudyArms: summaryText required');
+
+  const commonContextHash = sha256(commonContextText);
+  const arms = {
+    A: {
+      armId: 'A',
+      name: 'BASELINE_NO_ADDED_PRINCIPLE',
+      contentMode: 'none',
+      delivery: deliverPayload({ armId: 'A', content: null, budgetChars }),
+    },
+    B: {
+      armId: 'B',
+      name: 'TARGET_PRINCIPLE',
+      contentMode: 'policy',
+      delivery: deliverPayload({ armId: 'B', content: principleStatement, budgetChars }),
+      frozenCandidate: freezeCandidate({ policyText: principleStatement, sourceStage: 'principle-frozen', deliveredRepresentation: 'statement' }),
+    },
+    C: {
+      armId: 'C',
+      name: 'EXPERIENCE_SUMMARY',
+      contentMode: 'summary',
+      delivery: deliverPayload({ armId: 'C', content: summaryText, budgetChars }),
+      frozenCandidate: freezeCandidate({ policyText: summaryText, sourceStage: 'experience-summary-frozen', deliveredRepresentation: 'summary' }),
+    },
+  };
+  return { commonContextText, commonContextHash, budgetChars, arms };
+}
+
+/** Compose the full actor-visible prompt for an arm (audit surface only). */
+export function composeArmPrompt({ arms, armId, taskText }) {
+  const arm = arms[armId];
+  if (!arm) throw new Error(`composeArmPrompt: unknown armId ${armId}`);
+  return composeActorPrompt({ taskText, delivery: arm.delivery });
+}
+
+/**
+ * Static isolation audit over the built arm configs:
+ *  - A's composed prompt must contain neither the principle statement, nor
+ *    the summary text, nor any normative marker (keyword proxy for
+ *    principle-synonymous content; hash equality is covered separately).
+ *  - B must deliver exactly the frozen statement (payloadHash equality).
+ *  - C must deliver the summary and must NOT contain the normative markers.
+ *  - All arms share the same commonContextHash and budget policy.
+ * This is a STATIC config audit. It proves nothing about real hosts (see the
+ * study's a-baseline-contamination-audit.json for the UNKNOWN boundary).
+ */
+export function auditArmIsolation({ arms, commonContextText, taskText, normativeMarkers }) {
+  const problems = [];
+  const summaryText = arms.C.delivery.payloadText;
+  const principleStatement = arms.B.delivery.payloadText;
+  if (arms.A.delivery.payloadText !== '') problems.push('arm A payload must be empty');
+  if (arms.B.delivery.payloadHash !== arms.B.frozenCandidate.contentHash) problems.push('arm B payloadHash != frozenCandidate.contentHash');
+  const promptA = composeArmPrompt({ arms, armId: 'A', taskText });
+  const promptB = composeArmPrompt({ arms, armId: 'B', taskText });
+  const promptC = composeArmPrompt({ arms, armId: 'C', taskText });
+  if (promptA.includes(principleStatement)) problems.push('arm A composed prompt contains the principle statement');
+  if (promptA.includes(summaryText)) problems.push('arm A composed prompt contains the summary text');
+  for (const marker of normativeMarkers) {
+    if (promptA.includes(marker)) problems.push(`arm A composed prompt contains normative marker: ${marker}`);
+    if (promptC.includes(marker)) problems.push(`arm C payload contains normative marker (summary must not carry the normative rule): ${marker}`);
+  }
+  if (!promptB.includes(principleStatement)) problems.push('arm B composed prompt must contain the frozen principle statement');
+  if (promptC.includes(principleStatement)) problems.push('arm C payload must not contain the verbatim principle statement');
+  const commonHashes = new Set([arms.A, arms.B, arms.C].map(() => arms.commonContextHash ?? sha256(commonContextText)));
+  if (commonHashes.size !== 1) problems.push('arms disagree on common context hash');
+  return {
+    ok: problems.length === 0,
+    problems,
+    evidence: {
+      aPayloadEmpty: arms.A.delivery.payloadText === '',
+      bPayloadHash: arms.B.delivery.payloadHash,
+      cPayloadHash: arms.C.delivery.payloadHash,
+      promptALength: promptA.length,
+      markersChecked: normativeMarkers.length,
+    },
+  };
+}