@oevery/rsp 3.2.0 → 4.0.0

package/skills/rsp-shape/SKILL.md

@@ -1,35 +1,43 @@
 ---
 name: rsp-shape
-description: Shape or rigorously challenge unclear non-trivial work into one executable RSP Change or a justified shallow Change Group without implementing it.
+description: Resolve bounded design questions read-only or clarify material choices and plan authorized work as one executable Change or justified shallow Group. Not decision approval, implementation or final-record cleanup.
 license: MIT
 metadata:
   author: oevery
-  version: "2026.08.05.1"
+  version: "2026.10.15.2"
 ---
 
 # RSP Shape
 
-Do not implement the shaped work.
+For tracked work, read the [shared work model](../rsp/references/work-model.md) when its identity and ownership definitions are missing from the current context. Use logical WorkRefs in commands and reports; cite file locations separately. Direct invocation needs no prior Core execution.
 
-Follow Core's response-versus-artifact language boundary for all user-visible control narration; when the response language differs, keep exact canonical values only as secondary parenthesized or code-formatted tokens.
+Choose the branch before loading detail: bounded design advice is read-only and may have no Change; explicit planning-artifact work shapes or refines a Change/Group. Neither branch implements product behavior.
+
+Shape clarifies decisions and writes planning artifacts, including Markdown. The authorized DecisionOwner approves material choices. Doc may word settled decisions and reconcile final work records. Return unresolved material choices to Shape; prose cleanup cannot settle them.
+
+Responses follow explicit instruction, personal instructions, then conversation language. Preserve existing artifact language and canonical identifiers, commands and values. For new artifacts, use explicit instruction, effective configuration, scoped project instructions, then conversation language.
+
+Resolve needed RSP settings, including defaults and inheritance, through the selected CLI's successful `rsp config --json` summary; refresh on relevant drift or recovery. Raw YAML is diagnostic only. Projection failure blocks dependent choices, not independent authorized work; return material conflicts to the owner.
 
 ## Establish the boundary
 
-Read the request, authority, Core or fallback, Change and Brief, then only decisive evidence.
+Read the request, authority, nearest project context, Change and Brief when selected, then only decisive evidence. A direct design question without a Change does not require one. A design question inside a tracked Change retains that WorkRef, but defaults to report-only; only explicit artifact authority permits updating its Design.
 
 A request to shape, create, or refine a Change grants artifact authority unless no-edit; advice does not. If creation focuses it, preserve the exact prior focus and restore it immediately unless selection was requested. Shaping grants no other authority; preserve unrelated work.
 
-Return the request directly to implementation when it is tiny and concrete or the selected Change is already ready. Do not rewrite settled work for style or completeness.
-
-During an explicit managed goal, its original planning-artifact authority remains valid for clear in-scope discovery. Keep a cohesive correction in the current Change; create one Change for an independently closable result, or one shallow Group for at least two such results sharing the goal. Return the ready WorkOwner to Core for fresh qualification without another authorization round. Stop on changed behavior, acceptance, public interfaces, goal scope, mutation authority, or external action.
+Route concrete or ready work to implementation only when authorized and no design/planning question remains. An explicit read-only design request still ends with its report. Do not rewrite settled work for style or completeness.
 
 ## Resolve material ambiguity
 
-Inspect the repository before asking. Ask only for an owner decision changing behavior, data, interfaces, compatibility, safety, ownership, migration, or acceptance. Write only authorized answers.
+Inspect the repository before asking. Ask for unresolved owner decisions affecting behavior, data, interfaces, compatibility, safety, ownership, migration or acceptance. Reuse settled answers until evidence invalidates them. Ordinary implementation choices within that contract need no new decision or planning pass. Write only authorized answers.
 
-Shape owns two transient questioning modes. Ordinary clarification asks one to three related material questions, while explicit deep clarification asks exactly one DecisionOwner question per turn. A Core or Manage `StopDisposition: return-to-shape` may enter either mode, but Shape resumes execution only by returning a ready WorkOwner to Core for fresh route derivation; it never resumes Manage directly.
+Derive requirements and acceptance checks from settled authority. Do not make a preferred implementation or unsettled public behavior, failure contract, default or compatibility choice mandatory. Keep replaceable internal choices in Design, label material alternatives as proposals and put readiness-blocking decisions in Blockers.
 
-Read [deep clarification](references/deep-clarification.md) when the user explicitly asks for rigorous challenge, a high-risk decision remains, or one design question returns. Prefer the installed `rsp-design` capability; otherwise use its fallback.
+Choose permitted methods within the branch. Recover a diagnosed read/search fault against unchanged goal, scope, authority, baseline and evidence. Inspect artifact/focus effects before replaying planning mutations; unknown effects or unsafe replay stop that action. Required RSP commands/checks cannot be replaced by prose or tool status.
+
+Ask one to three related material questions ordinarily, one DecisionOwner question per turn for deep clarification. Resume unresolved decisions from fresh facts and return the ready owner to Core; a method change alone restarts no workflow.
+
+For a bounded design question, load only the relevant [domain modeling](references/domain-modeling.md), [module and seam design](references/module-seams.md), or [reversible exploration](references/reversible-exploration.md) method. Read [deep clarification](references/deep-clarification.md) only for explicit rigorous challenge or dependent high-risk decisions. Advice does not create or modify an artifact, authorize a disposable code probe, or turn a recommendation into product authority.
 
 Read [external issue input](references/external-issue-input.md) only when a Change declares an issue relationship or the request asks to shape from an issue URL.
 
@@ -37,43 +45,14 @@ Never invent a product decision. When a material choice or mutation authority re
 
 ## Choose the owner
 
-Read [complex shaping](references/complex-shaping.md) when clarification needs multiple rounds, slices share one completion contract, or independently closable owners converge on terminal delivery.
-
-When Shape must establish a new WorkRef, preserve an explicit valid user-supplied identity through canonical normalization. Otherwise follow an explicit nearest project or domain WorkRef naming convention. If neither exists, infer ASCII lowercase kebab-case from stable domain or technical vocabulary. Artifact, commit, response, host locale, and TUI language settings never select or translate WorkRef language. Safe Unicode remains available through explicit input or project/domain convention; never rename an existing open or archived identity because language or naming guidance changes.
-
-Prefer one ordinary Change only for one observable outcome sharing a consistency, focused-verification, review, archive, and rollback boundary. Change granularity does not prescribe Git commit count; never split or merge Changes merely to enforce a Change-to-commit mapping. Use a shallow Group for independent outcomes under one goal; an integration gate never merges them. A shared completion contract gates Group closure, not child archive unless declared there. Keep Brief `Slices`, child `Blockers`, and derived readiness. Add no hierarchy.
+For authorized planning-artifact work, read [planning and readiness](references/planning.md) before choosing or naming an owner, writing a Change/Group, or updating the selected Design. Read-only design advice needs none of those artifact procedures.
 
-Keep one observable outcome per Change:
-
-- `Proposal`: outcome, scope, non-goals;
-- `Spec`: requirements and acceptance;
-- `Design`: boundaries and choices;
-- `Tasks`: executable steps;
-- `Verify`: decisive evidence;
-- `Blockers`: dependencies and decisions, or `none`.
-
-Plan a test only when it protects observable behavior or a real boundary, adds distinct future confidence, avoids duplicate or implementation-detail coverage, and costs proportionately. Otherwise prefer smallest sufficient evidence and keep probes temporary.
-
-A Change is a convergent current-plan/final-evidence snapshot, not an append-only execution log. Replace superseded evidence; keep process in the response. Before archive, retain final decisive verification, gaps, and risks.
-
-Use domain language. Mention agents only as real product actors or constraints, not authors or execution narrators.
+Read [complex shaping](references/complex-shaping.md) when authorized planning involves multiple material decisions or independently acceptable outcomes with dependencies/integration. Work shape does not enable agent delegation.
 
 ## Apply the Shape Ready gate
 
-A Change is ready only when:
-
-- outcome, non-goals, and acceptance are concrete;
-- product and mutation authority are settled;
-- affected boundaries and material constraints are known;
-- no hidden assumption can change implementation or acceptance;
-- Tasks are executable without performing them;
-- Verify proves the result without process chronology; Blockers are truthful;
-- one Change or a justified shallow Group is the smallest sufficient owner.
-
-After mutation, run the focused RSP check. Return WorkRef, artifacts, validation, and next action or blocker.
-
-When the gate passes, return a `ControlOutcome` for phase Shape with the ready `WorkOwner` WorkRef, decisive readiness evidence, `NextOwner: Core`, and a resume rule that Core freshly derives the route.
+For planning, apply the complete [Shape Ready gate](references/planning.md#apply-the-shape-ready-gate), then run the focused RSP check after authorized mutation. On pass, return the ready Change WorkRef or Group reference, artifacts and decisive evidence for Core to continue the authorized objective without another user request.
 
-When a material decision prevents readiness, return a non-ready `ControlOutcome` for phase Shape with `StopDisposition: ask-owner`, the decisive evidence, the `DecisionOwner`, the required answer, and a resume rule that reruns Shape from fresh evidence after the answer.
+For read-only design, lead with the recommendation and decisive evidence. Include credible tradeoffs, owner decisions and a next action only when relevant to the current question; do not restate settled context or force a planning report. Create or mutate no plan automatically.
 
-For any other blocker, return a non-ready Shape `ControlOutcome` with the applicable canonical `StopDisposition`, decisive evidence, `NextOwner`, required input, and resume rule. Do not relabel unresolved fog as ready work.
+When a material decision prevents readiness, stop with decisive evidence, the DecisionOwner and required answer; resume from fresh relevant evidence after that answer. For other blockers, state the actual missing input, next owner and safe resume condition. Use canonical machine fields such as `StopDisposition` only when a real consumer requires them. Do not report unresolved material decisions as ready work.

package/skills/rsp-shape/references/complex-shaping.md

@@ -1,6 +1,8 @@
 # Complex shaping
 
-Read this reference only when material clarification needs more than one round, several direct slices share one completion contract, or independently closable owners converge on terminal delivery.
+Read for authorized planning with multiple material decisions or independently acceptable outcomes with dependencies/integration. This method does not select agent topology.
+
+Use existing planning authority for clear in-scope discovery. Keep cohesive corrections in the Change. Use a separate Change for an independently closable result, or a shallow Group when at least two results have dependencies or integration obligations. Return the ready owner without another authorization round. Configuration grants no planning/product authority. Changes to behavior, acceptance, interfaces, scope, mutation authority or external action need an owner decision.
 
 ## Close material decisions
 

package/skills/rsp-shape/references/deep-clarification.md

@@ -8,15 +8,15 @@ Inspect the available code, tests, project instructions, Specs, and Decision Rec
 
 ## RSP design return
 
-When `rsp-design` is available, it is the canonical domain or module design capability for an RSP-tracked question. Otherwise use an equivalent project-selected capability or Core's compact manual design fallback. Return one bounded design task containing:
+For an RSP-tracked domain or module design question, use Shape's conditional design method and return one bounded result containing:
 
 - the unresolved design question;
 - authoritative project inputs by path;
 - the expected existing artifact or decision output;
 - its permitted mutation boundary;
-- the same returning WorkRef.
+- the same returning WorkOwner reference.
 
-The selected capability owns only the design analysis, while existing project documents retain domain and architecture authority. Consume its settled result and evidence on return, then resume Shape against the same Change.
+Design analysis does not grant artifact mutation; existing project documents retain domain and architecture authority. Consume settled evidence in the same Shape request and continue against the same Change only when authorized.
 
 ## Traverse one decision at a time
 
@@ -28,4 +28,4 @@ This branch fulfills `StopDisposition: return-to-shape`; it does not resume the
 
 ## Completion criterion
 
-Finish the deep branch when every material dependent decision is either owner-confirmed or recorded as one explicit blocker, the project design task has returned to the same WorkRef when used, and no artifact changed before shared understanding was confirmed.
+Finish the deep branch when every material dependent decision is either owner-confirmed or recorded as one explicit blocker, the project design task has returned to the same WorkOwner when used, and no artifact changed before shared understanding was confirmed.

package/skills/rsp-shape/references/domain-modeling.md

@@ -0,0 +1,13 @@
+# Domain modeling (Shape design method)
+
+Use this procedure only for a question about domain language, identity, lifecycle, invariants, relationships, or ownership.
+
+Use authoritative context, Specs, code, tests and user language to resolve:
+
+- Existing terms and contradictions; do not silently choose a conflicting source.
+- Identity, owners, allowed transitions, invariants and relationships. Distinguish domain concepts from transport, storage, UI and helper representations.
+- Observable lifecycle scenarios across creation, transitions, failure, cancellation, deletion and relevant scope boundaries, not type names alone.
+
+Propose the smallest coherent model explaining the evidence. Check it against at least one edge case and one existing production consumer; separate evidence-forced conclusions from choices needing owner confirmation.
+
+Return canonical terms, definitions, ownership and lifecycle implications, conflicts with current usage, alternatives, and unresolved owner decisions. Planned vocabulary may update only the authorized selected Change `Design`; flag possible current-fact or rationale destinations without writing them.

package/skills/rsp-shape/references/module-seams.md

@@ -0,0 +1,13 @@
+# Module and seam design (Shape design method)
+
+Use this procedure only for a question about an interface, caller complexity, adapter, test surface, or seam placement.
+
+Before proposing a seam, trace the direct production consumer's complete call/data path and confirm it reaches the candidate owner. Then judge:
+
+- Caller obligations: inputs, outputs, invariants, ordering, failures, configuration, cancellation and relevant performance constraints.
+- Actual behavior/policy variation, not hypothetical interfaces or pass-through wrappers for symmetry.
+- Credible placements by caller leverage, implementation locality, dependency direction, state ownership and a public surface usable by both callers and tests.
+
+Recommend the smallest interface hiding meaningful complexity without moving domain ownership. State migration and compatibility consequences; implement nothing.
+
+Return the proposed owner, seam, interface obligations, affected consumers, verification surface, alternatives, and unresolved owner decisions. Treat code sketches as explanatory output only; do not write production code.

package/skills/rsp-shape/references/planning.md

@@ -0,0 +1,42 @@
+# Authorized planning and readiness
+
+Load only for authorized planning-artifact work, before choosing or naming an owner, creating/refining a Change or Group, or updating the selected Change Design. Advice alone grants no artifact mutation.
+
+## Choose and name the owner
+
+For a new WorkRef, canonically normalize a valid user-supplied identity. Otherwise follow the nearest explicit project/domain naming convention; absent both, infer ASCII lowercase kebab-case from stable domain or technical terms. Artifact, commit, response, host locale and TUI language settings do not select or translate WorkRefs. Explicit input or project/domain conventions may use safe Unicode. Language or naming changes never rename existing open or archived identities.
+
+Prefer one ordinary Change only for one observable outcome sharing a consistency, focused-verification, review, archive, and rollback boundary. Change granularity does not prescribe Git commit count; never split or merge Changes merely to enforce a Change-to-commit mapping. Use a shallow Group for independently acceptable/deliverable outcomes with dependencies or integration obligations; complexity and worker count alone do not justify it; an integration gate never merges them. A shared completion contract gates Group closure, not child archive unless declared there. Keep Brief `Slices`, child `Blockers`, and derived readiness. Add no hierarchy.
+
+## Write one outcome
+
+Keep one observable outcome per Change:
+
+- `Proposal`: outcome, scope, non-goals;
+- `Spec`: settled contract delta and acceptance, referencing affected existing Specs rather than copying the baseline or inventing public promises;
+- `Design`: approach, responsibility boundaries, and necessary tradeoffs, not repeated requirements or tasks;
+- `Tasks`: checkable work, with prescribed order only where correctness, safety, or migration requires it;
+- `Verify`: methods proving settled acceptance, not adding new public requirements; then actual decisive results, gaps, and limits, not repeated requirements or transcripts;
+- `Blockers`: dependencies and decisions, or `none`.
+
+Keep the six sections; small changes need only proportionate content. Plain-prose HTML scaffold hints may remain or be removed; they guide writing, never supply requirements, evidence, or completed content. Resolve body placeholders and keep all material decisions visible outside comments.
+
+Plan a test only when it protects observable behavior or a real boundary, adds distinct future confidence, avoids duplicate or implementation-detail coverage, and costs proportionately. Otherwise prefer smallest sufficient evidence and keep probes temporary.
+
+A Change is a convergent plan and final-result snapshot. Ongoing recovery notes belong in Focus; detailed evidence stays with its owner. Before closeout, establish verified outcomes, selectively update stable knowledge at its owner, then reconcile the final Change with those facts and references. These may be one operation and already-accurate text needs no edit. Do not append execution history.
+
+Use domain language. Mention agents only as real product actors or constraints, not authors or execution narrators.
+
+## Apply the Shape Ready gate
+
+A Change is ready only when:
+
+- outcome, non-goals, and acceptance are concrete;
+- product and mutation authority are settled;
+- affected boundaries and material constraints are known;
+- no hidden assumption can change implementation or acceptance;
+- Tasks are executable without performing them;
+- Verify proves the result without process chronology; Blockers are truthful;
+- one Change or a justified shallow Group is the smallest sufficient owner.
+
+After authorized planning mutation, run the focused RSP check. Readiness permits Core to continue only the already authorized objective; it grants no product, lifecycle, Git or external authority.

package/skills/{rsp-design → rsp-shape}/references/reversible-exploration.md

@@ -1,4 +1,4 @@
-# Reversible exploration
+# Reversible exploration (Shape design method)
 
 Use this procedure only when a material design conclusion depends on behavior that available code, tests, documentation, or runtime evidence does not establish.
 
@@ -12,7 +12,7 @@ Use this procedure only when a material design conclusion depends on behavior th
 
 - Keep disposable code outside production owners and name it clearly as temporary. Do not change public interfaces, migrations, persistent data, credentials, or delivery state.
 - Record the pre-probe file state and exact cleanup target. Avoid the probe when unrelated work makes safe cleanup uncertain.
-- Run only the minimum observation, capture the evidence, then remove every disposable artifact before returning. Verify cleanup without discarding unrelated work.
+- Run only the minimum observation and capture the evidence. If the probe fails, inspect actual effects before a repeat or cleanup; never replay a one-shot action or guess at an unknown mutation. Remove every disposable artifact within the exact authorized cleanup boundary before returning, and verify cleanup without discarding unrelated work. Report any cleanup that cannot safely be completed.
 
 ## Return evidence, not architecture
 

package/skills/rsp-verify/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: rsp-verify
+description: Collect and report one selected RSP WorkOwner's declared check evidence, including separately required independent verification. Read-only; fixed-scope semantic judgment belongs to Review even when it includes checks.
+license: MIT
+metadata:
+  author: oevery
+  version: "2026.10.12.1"
+---
+
+# RSP Verify
+
+For tracked work, read the [shared work model](../rsp/references/work-model.md) when its identity and ownership definitions are missing from the current context. Use logical WorkRefs in commands and reports; cite file locations separately. Direct invocation needs no prior Core execution.
+
+Collect declared-check evidence for one existing RSP WorkOwner when requested or separately required. Return one bounded read-only result. Review may run supporting checks without invoking Verify. Honor combined requests and required independent evidence; this Skill supplies no host independence. Verify is a Discipline for evidence collection, not routing, control, lifecycle, semantic review or Git delivery.
+
+## Require a declared boundary
+
+Require one selected WorkOwner, declared boundary, comparison baseline and authority for the named checks. An explicit reference wins; otherwise resolve one FocusSet candidate from user intent and status. Multiple markers are valid.
+
+- **Change:** use its WorkRef and its `Verify` section for the declared boundary.
+- **Group:** use its Group reference and named `Integration:` condition in the Brief's `Completion Conditions`; child evidence stays with each child WorkRef. An explicit request may supply an in-progress temporary boundary, which must be written back before Group closeout.
+
+Stop for ambiguous owner, scope, baseline, required evidence or environment, or a Group without a named boundary for the requested verification.
+
+Read nearest project instructions and the available project protocol, selected Change and Brief, relevant Specs and Decisions, current diff, blockers, and the smallest production path needed to understand the declared check. This package needs no installed Core Skill. Do not invent checks from generic testability or replace an unexplained failure with a guessed assertion; return that symptom for read-only diagnosis.
+
+## Preserve read-only authority
+
+Do not edit product files, Changes, Specs, Decisions, focus markers, archives, configuration, or Git state. Do not start publication, deployment, approval, or human-acceptance actions. Running a declared local test, build, typecheck, lint, browser check, or other environment check is evidence collection only and retains the authority required by that command.
+
+Use the caller's result contract when supplied, otherwise the direct result below. Core owns response coordination, dispatch, result validation, acceptance and closeout; Verify supplies evidence, never worker identity/isolation, `review-clean` or `archiveReady`. Identity and independence require host observations.
+
+## Collect the declared evidence
+
+Compare existing evidence with the declared baseline. Reuse traceable passes while their tested scope and relevant content, dependencies, configuration, tools, inputs and environment still apply. Run missing, failed or invalidated named checks and any explicitly required execution, current-environment observations or independent execution. Corrections and integration need fresh evidence for affected inputs or an enlarged boundary; a phase change alone requires no rerun.
+
+Compare each check's actual targets, inputs, coverage and completion with its declaration. Retain commands, scope, sources and results; distinguish reused evidence from new execution. Invocation errors or incomplete observations alone prove no product defect; exit status alone establishes no acceptance.
+
+For a tool-only obstacle, diagnose read-only and inspect actual effects before continuing:
+
+- Change a permitted collection method only with unchanged goal, owner, scope, baseline, authority and required evidence, and demonstrably safe replay.
+- Run a named mandatory command/check as required; substitutes supply no pass.
+- Do not repair product/workflow state, manually replace command-owned RSP operations, replay one-shot work or continue with unknown mutation effects.
+
+## Return one bounded result
+
+Return exactly one canonical result from the collected evidence, with observed failure taking precedence over unavailable coverage:
+
+- `fail`: at least one named required check has observed failure, even when another check is unavailable.
+- `unavailable`: no named required check has observed failure, but a required tool, dependency, service, credential, or environment could not be used.
+- `pass`: every named required check passed within the declared boundary.
+
+Report each check's outcome, including missing or unexecuted checks. Aggregation changes neither coverage nor stop conditions. Failure does not imply complete coverage; unavailable evidence does not erase observed failures.
+
+Include these independent fields and their evidence:
+
+- `evidence_delta: new | none`: whether the result changes the next diagnosis or correction.
+- `boundary: unchanged | changed`: whether observed owner, paths, baseline, behavior, interface, scope and authority still match the declared boundary.
+- WorkOwner and applicable Change WorkRef or Group `Integration:` condition; lane objective and effective authority.
+- Named checks, comparison baseline, observed diff, decisive evidence with reused versus newly executed results, omissions and stop boundary.
+
+Preserve exact machine values and all required result information. Present them concisely without repeated logs or evidence; a requested machine schema remains exact. Human-facing narration follows a supplied response-language contract; otherwise use explicit user instruction, then personal instructions, then conversation language.
+
+`pass` proves only declared checks, not semantic review, writeback, archive/commit eligibility, publication, deployment, approval or human acceptance. It grants no lifecycle, Git, external or acceptance authority.
+
+Long-running verification remains active while its boundary and stop conditions hold. Elapsed time, heartbeat, polling and progress messages do not change the result.
+
+## Stop and return
+
+Stop when evidence is missing, the environment is unavailable, the boundary changes or a required check cannot be observed. Use the caller's canonical stop reason only when supplied. For direct invocation, identify the missing input or changed boundary and the required next action; do not invent a completed verification result before the declared boundary is established.
+
+On cancellation, wait until the command or owned process is observed stopped before beginning conflicting work. Return the result, decisive evidence, omissions and next action to the caller or user. Retry only with new evidence and safe replay inside the declared boundary.

package/dist/chunk-JOMFFQRG.mjs

@@ -1,99 +0,0 @@
-#!/usr/bin/env node
-
-// src/tui/terminal.ts
-function openTerminalSession(stdout, options) {
-  let cleaned = false;
-  if (!options.screenReader)
-    stdout.write("\x1B[?1049h\x1B[?25l");
-  return {
-    cleanup() {
-      if (cleaned)
-        return;
-      cleaned = true;
-      if (!options.screenReader)
-        stdout.write("\x1B[?25h\x1B[?1049l");
-    }
-  };
-}
-
-// src/tui/display.ts
-var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-function isWide(codePoint) {
-  return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 129791 || codePoint >= 131072 && codePoint <= 262141);
-}
-function displayWidth(value) {
-  let width = 0;
-  for (const { segment } of segmenter.segment(value)) {
-    const codePoint = segment.codePointAt(0) ?? 0;
-    if (/^\p{Mark}$/u.test(segment) || codePoint === 8205)
-      continue;
-    width += isWide(codePoint) ? 2 : 1;
-  }
-  return width;
-}
-function truncateDisplay(value, maxWidth) {
-  if (displayWidth(value) <= maxWidth)
-    return value;
-  if (maxWidth <= 1)
-    return "\u2026".slice(0, maxWidth);
-  let result = "";
-  for (const { segment } of segmenter.segment(value)) {
-    if (displayWidth(result + segment) > maxWidth - 1)
-      break;
-    result += segment;
-  }
-  return `${result}\u2026`;
-}
-function wrapDisplay(value, maxWidth, firstPrefix = "", continuationPrefix = firstPrefix) {
-  const width = Math.max(1, maxWidth);
-  if (displayWidth(firstPrefix) >= width)
-    return [truncateDisplay(`${firstPrefix}${value}`, width)];
-  const lines = [];
-  let prefix = firstPrefix;
-  let line = prefix;
-  const pushLine = () => {
-    lines.push(line);
-    prefix = continuationPrefix;
-    line = prefix;
-  };
-  const appendUnbroken = (token) => {
-    for (const { segment } of segmenter.segment(token)) {
-      if (displayWidth(line + segment) > width && line !== prefix)
-        pushLine();
-      if (displayWidth(line + segment) > width) {
-        lines.push(truncateDisplay(line + segment, width));
-        prefix = continuationPrefix;
-        line = prefix;
-        continue;
-      }
-      line += segment;
-    }
-  };
-  let pendingWhitespace = "";
-  for (const token of value.split(/(\s+)/u).filter(Boolean)) {
-    if (token.trim().length === 0) {
-      if (line !== prefix)
-        pendingWhitespace += token;
-      continue;
-    }
-    const separator = line === prefix ? "" : pendingWhitespace;
-    if (displayWidth(line + separator + token) <= width) {
-      line += `${separator}${token}`;
-    } else {
-      if (line !== prefix && separator)
-        pushLine();
-      appendUnbroken(token);
-    }
-    pendingWhitespace = "";
-  }
-  if (line !== prefix || lines.length === 0)
-    lines.push(line);
-  return lines;
-}
-
-export {
-  openTerminalSession,
-  displayWidth,
-  truncateDisplay,
-  wrapDisplay
-};