@tiinex/app 0.1.1

package/src/schemas/workspace/workspace.chrome.views.jsx

@@ -0,0 +1,299 @@
+import React from 'react';
+import { Button } from '../../ui/primitives/Button.jsx';
+import { Icon } from '../../ui/primitives/Icon.jsx';
+import { workspaceEmptyStateCopy } from '../../workspaces/workspace.emptyStateCopy.js';
+import { displayOptionsActiveConstraintCount } from '../../workspaces/workspace.displayOptions.js';
+import { recordSourceClass } from '../../workspaces/workspace.displayFilters.js';
+import { shouldShowWorkspaceSummary } from '../../workspaces/workspace.summary.js';
+import { isLocalSessionMaterial } from '../../workspaces/workspace.localSourceLifecycle.js';
+import { normalizeGithubTransportTier } from '../../sources/github/github.transport.js';
+import { isOriginReferenceSource } from '@tiinex/core/sources/origin.references.js';
+import { sourceTransportBadgesForSource } from '../../app/sourceTransportRefresh.js';
+import { buildGovernanceBoundaryForSource, GOVERNANCE_BOUNDARY_SCHEMA_ID } from '@tiinex/core/governance/governance.boundary.js';
+import { SourceReceiptDetails } from './workspace.sourceReceipt.views.jsx';
+
+export function WorkspaceBoundaryKicker({ workspace = {} }) {
+  const records = Array.isArray(workspace.records) ? workspace.records : [];
+  const assets = Array.isArray(workspace.assets) ? workspace.assets : [];
+  const localCount = records.filter((record) => recordSourceClass(record) === 'local').length
+    + records.filter((record) => record?.materialReconciliation?.status === 'checksum-match' && record.materialReconciliation.localSnapshot).length
+    + assets.filter((asset) => isLocalSessionMaterial(asset)).length;
+  const sourceCount = records.filter((record) => recordSourceClass(record) === 'source-backed').length;
+  if (!localCount && !sourceCount) return null;
+  const label = sourceCount && localCount ? 'mixed' : sourceCount ? 'source-backed' : 'local';
+  const title = sourceCount && localCount
+    ? 'Workspace contains both browser-local and explicit source-backed material.'
+    : sourceCount
+      ? 'Workspace is currently showing explicit source-backed material.'
+      : 'Browser-local session material; source provenance is not inferred.';
+  return <span className={`tx-window-kicker tx-boundary-workspace-kicker tx-${label}`} title={title}><Icon name={sourceCount ? 'source' : 'workspace'} /><span>{label}</span></span>;
+}
+
+export function SourceStrip({ workspace, boundary, onCloseSource, onOpenAddDialog, onSourceTransportRefresh, onOpenGovernance, readOnly = false }) {
+  const sources = (Array.isArray(workspace.sources) ? workspace.sources : []);
+  if (!sources.length) return null;
+  return (
+    <div className="tx-source-strip workspace-source-strip tx-compact-source-strip" aria-label="Workspace sources">
+      <div className="tx-source-list">
+        {sources.map((source) => {
+          const closeable = Boolean(source.closeable);
+          const kind = String(source.adapterId || source.sourceKind || source.kind || '').toLowerCase();
+          const isLocal = kind.includes('local') || source.id === 'local';
+          const isOriginRecovery = isOriginReferenceSource(source) || source.recoveryOnly === true;
+          const isTargetedFileRecovery = source.sourceKind === 'github.file' && source.loadable === false;
+          const transport = isOriginRecovery ? originRecoveryTransportSummary(source) : sourceTransportSummary(source);
+          const sourceLabel = source.label || source.id || 'Source';
+          const addTitle = isLocal ? 'Add local files, archive imports, or workspace artifacts' : 'Open source controls for this source: choose repo files, explicit files, or issue snapshots';
+          const addLabel = isLocal ? 'Add' : 'Discover';
+          const canLoadFromSource = closeable && !isOriginRecovery && source.loadable !== false;
+          const closeTitle = isLocal ? (source.closeLabel || 'Clear local/session material') : isOriginRecovery ? `Dismiss recovery origin ${sourceLabel}` : `Close ${sourceLabel}`;
+          const closeAria = isLocal ? 'Clear Local source material from this browser session' : isOriginRecovery ? `Dismiss recovery-only origin ${sourceLabel}` : `Close ${sourceLabel}`;
+          return (
+            <span
+              key={source.id || source.label}
+              className={`tx-source-pill ${closeable ? 'tx-source-pill-closeable' : ''} ${isOriginRecovery ? 'tx-source-origin-recovery' : kind.includes('github') ? 'source-github' : 'source-local'}`}
+              title={source.boundary || boundary || ''}
+              data-discovery-state={source.discoveryState || undefined}
+              data-source-kind={kind || undefined}
+              data-source-role={isOriginRecovery ? 'origin-recovery' : isLocal ? 'local-session' : isTargetedFileRecovery ? 'targeted-provenance' : 'configured-source'}
+            >
+              <Icon name={kind.includes('github') ? 'source' : 'workspace'} />
+              <strong>{sourceLabel}</strong>
+              <small title={isOriginRecovery ? 'Explicit origin references recovered from imported/local artifacts, not loaded source records.' : undefined}>{sourceCountText(source, isOriginRecovery)}</small>
+              {isOriginRecovery ? <span className="tx-source-role-badge" title="Recovery-only origin: imported records remain local/session authority.">recovery only</span> : null}
+              {transport.badges?.length ? <span className={`tx-source-transport-group ${transport.mixed ? 'is-mixed' : ''}`} aria-label={transport.mixed ? 'Surface transports' : 'Source transport'}>
+                {transport.badges.map((badge) => badge.refreshable ? (
+                  <button key={badge.key} type="button" className={`tx-source-transport tx-source-transport-button ${badge.className}`} title={badge.title} aria-label={badge.title} onClick={() => onSourceTransportRefresh?.(source.id, badge.refreshTier || badge.tier, badge.surfaceKeys || [])}>{badge.label}</button>
+                ) : (
+                  <span key={badge.key} className={`tx-source-transport ${badge.className}`} title={badge.title}>{badge.label}</span>
+                ))}
+              </span> : null}
+              <SourceGovernanceBadge source={source} onOpenGovernance={onOpenGovernance} />
+              {canLoadFromSource && !readOnly ? <button type="button" className="tx-source-load" aria-label={`${addLabel} material for ${sourceLabel}`} title={addTitle} onClick={() => onOpenAddDialog?.(isLocal ? '' : source.id)}><Icon name="add" /><span>{addLabel}</span></button> : null}
+              {closeable && !readOnly ? <button type="button" className="tx-source-close" aria-label={closeAria} title={closeTitle} onClick={() => onCloseSource?.(source.id)}><Icon name="close" /></button> : null}
+            </span>
+          );
+        })}
+      </div>
+    </div>
+  );
+}
+
+
+function sourceCountText(source = {}, originRecovery = false) {
+  if (!originRecovery) return Number(source.count || 0);
+  const refs = Number(source.originReferenceCount || 0);
+  return refs ? `${refs} ref${refs === 1 ? '' : 's'}` : '0 loaded';
+}
+
+function originRecoveryTransportSummary(source = {}) {
+  return {
+    badges: [{
+      key: 'origin-recovery',
+      label: 'recovery',
+      tier: 'direct',
+      refreshTier: '',
+      refreshable: false,
+      title: source.boundary || 'Explicit origin metadata is available for user-invoked lineage recovery; this is not a configured source and does not make imported material source-backed.',
+      className: 'tx-transport-tier-direct tx-transport-origin-recovery'
+    }],
+    mixed: false
+  };
+}
+
+function SourceGovernanceBadge({ source = {}, onOpenGovernance }) {
+  if (isOriginReferenceSource(source) || source.recoveryOnly === true) return null;
+  const sourceKind = String(source.adapterId || source.sourceKind || source.kind || '').toLowerCase();
+  const repo = String(source.repo || source.repository || source.config?.repo || '').trim();
+  const explicitBoundary = source.governanceBoundary && typeof source.governanceBoundary === 'object' && source.governanceBoundary.schema === GOVERNANCE_BOUNDARY_SCHEMA_ID
+    ? source.governanceBoundary
+    : null;
+  const boundary = explicitBoundary || (sourceKind.includes('github') && repo
+    ? buildGovernanceBoundaryForSource(source, { rootChecked: false, discoveredFrom: 'source-strip-unchecked' })
+    : null);
+  if (!boundary || typeof boundary !== 'object') return null;
+  const status = String(boundary.status || '').trim();
+  if (!status || status === 'local') return null;
+  const policyKind = boundary.policy?.kind || '';
+  const label = status === 'found'
+    ? 'lineage policy'
+    : status === 'origin-fallback'
+      ? (policyKind || 'license')
+      : status === 'missing'
+        ? 'no policy'
+        : 'policy ?';
+  const title = `${boundary.note || boundary.boundary || 'Source governance boundary'} · Click to read governance context.`;
+  const className = `tx-source-governance tx-governance-${status}`;
+  if (typeof onOpenGovernance === 'function') {
+    return <button type="button" className={className} title={title} aria-label={`Open governance boundary: ${label}`} onClick={() => onOpenGovernance(source.id)}><Icon name={status === 'missing' ? 'warning' : 'audit'} /><span>{label}</span></button>;
+  }
+  return <span className={className} title={title} aria-label={`Governance boundary: ${label}`}><Icon name={status === 'missing' ? 'warning' : 'audit'} /><span>{label}</span></span>;
+}
+
+function sourceTransportSummary(source = {}) {
+  const plan = String(source.transportLabel || source.transport || 'cache → mirror → proxy → direct').replace(/\s*→\s*/g, ' → ');
+  const pendingTier = normalizeGithubTransportTier(source.transportOutcome?.pendingTier || '');
+  const badges = sourceTransportBadgesForSource(source).map((badge) => {
+    const pending = Boolean(badge.pendingTier || (pendingTier && (!Array.isArray(source.transportOutcome?.pendingSurfaces) || source.transportOutcome.pendingSurfaces.includes(badge.key))));
+    const tier = normalizeGithubTransportTier(badge.pendingTier || badge.tier || pendingTier || '') || 'cache';
+    const refreshTier = tier;
+    const status = String(badge.status || '').toLowerCase();
+    const titleParts = [
+      badge.mixed ? `${badge.label}: ${tier}` : `Source transport: ${tier}`,
+      badge.surfaceKeys?.length && badge.key !== 'all' ? `Surface: ${badge.surfaceKeys.join(', ')}` : '',
+      pending ? `Trying ${tier} now` : '',
+      Number(badge.loaded || 0) ? `${Number(badge.loaded || 0)} loaded` : '',
+      badge.unavailable ? 'Unavailable/skipped' : '',
+      badge.failed ? 'Failed' : '',
+      `Configured plan: ${plan}`,
+      badge.refreshable ? `Click: try ${badge.nextTier}` : 'Direct is the last fallback tier.'
+    ].filter(Boolean);
+    const text = badge.mixed && badge.shortLabel ? `${badge.shortLabel} ${tier}${pending ? '…' : ''}` : `${tier}${pending ? '…' : ''}`;
+    return Object.assign({}, badge, {
+      label: text,
+      tier,
+      refreshTier,
+      refreshable: Boolean(badge.refreshable && !pending),
+      title: titleParts.join(' · '),
+      className: [
+        `tx-transport-tier-${tier}`,
+        badge.mixed ? 'is-transport-surface' : '',
+        pending ? 'is-transport-pending' : '',
+        status === 'failed' || status === 'unavailable' || badge.unavailable || badge.failed ? 'is-transport-failed' : '',
+        status === 'ok' || Number(badge.loaded || 0) ? 'is-transport-ok' : ''
+      ].filter(Boolean).join(' ')
+    });
+  });
+  return { badges, mixed: badges.length > 1 };
+}
+
+export function WorkspaceMaterialSummary({ summary }) {
+  if (!shouldShowWorkspaceSummary(summary)) return null;
+  const counts = summary.counts || {};
+  const latest = summary.latestImport;
+  const latestDiagnostics = latest?.diagnostics || {};
+  const latestLedger = latestDiagnostics.materialLedgerReceipt || latestDiagnostics.materialLedger || null;
+  const ledgerExplainsVisibility = Boolean(latestLedger && (Number(latestLedger.hiddenRecords || 0) || Number(latestLedger.groupedRecords || 0) || Number(latestLedger.sourceWorkspaceArtifacts || latestLedger.legacySourceWorkspaceArtifacts || latestLedger.sourceWorkspaceArtifacts || 0)));
+  const noisyLatest = latest && (latest.ok === false || counts.errors || counts.warnings || counts.previewOmitted || ledgerExplainsVisibility);
+  return (
+    <section className="tx-workspace-material-summary" aria-label="Workspace material summary">
+      <div className="tx-material-summary-counts">
+        <span title="Loaded records before Display options"><Icon name="manualFiles" /><strong>{counts.records || 0}</strong><small>loaded records</small></span>
+        <span><Icon name="asset" /><strong>{counts.assets || 0}</strong><small>assets</small></span>
+        <span><Icon name="workspace" /><strong>{counts.workspaceArtifacts || 0}</strong><small>workspaces</small></span>
+        {counts.sourceBackedRecords ? <span><Icon name="source" /><strong>{counts.sourceBackedRecords}</strong><small>source-backed</small></span> : null}
+        {counts.hiddenRecords ? <span title="Loaded records not visible in the current feed/tree view. Grouped records are source+local material shown as one canonical card; display-hidden records are filtered/supporting/parent material still available for lineage."><Icon name="filters" /><strong>{counts.visibleRecords || 0}/{counts.records || 0}</strong><small>visible</small></span> : null}
+        {counts.groupedRecords ? <span title="Records grouped under a canonical source/local artifact cluster, not lost."><Icon name="check" /><strong>{counts.groupedRecords}</strong><small>grouped</small></span> : null}
+        {counts.hiddenByDisplayRecords ? <span title="Records hidden by Display options/search/leaf membership; still available for lineage and recovery."><Icon name="filters" /><strong>{counts.hiddenByDisplayRecords}</strong><small>display-hidden</small></span> : null}
+        {counts.lineageUsableRecords && counts.lineageUsableRecords !== counts.visibleRecords ? <span title="Records available to lineage/read-models, including material hidden by current display filters."><Icon name="lineage" /><strong>{counts.lineageUsableRecords}</strong><small>lineage usable</small></span> : null}
+        {counts.materialChecksumMatches ? <span title="Verified local/source equivalents were reconciled to one canonical source-backed artifact; redundant local duplicates are pruned instead of hidden for later resurrection."><Icon name="check" /><strong>{counts.materialChecksumMatches}</strong><small>deduped matches</small></span> : null}
+        {counts.localAssets ? <span title="Browser-local assets are locally available only; they are not source or public truth."><Icon name="asset" /><strong>{counts.localAssets}</strong><small>local assets</small></span> : null}
+        {counts.materialChecksumMismatches ? <span title="Imported/local material and source material share identity but checksum differs."><Icon name="warning" /><strong>{counts.materialChecksumMismatches}</strong><small>mismatch</small></span> : null}
+        {counts.recoveryOriginSources ? <span title="Explicit origins preserved from imported/local artifacts; recovery-only, not source-backed authority."><Icon name="source" /><strong>{counts.recoveryOriginSources}</strong><small>recovery origins</small></span> : null}
+      </div>
+      {noisyLatest ? (
+        <div className={`tx-material-summary-import ${latest.ok ? 'tx-import-ok' : 'tx-import-degraded'}`} title={latest.message}>
+          <Icon name={latest.ok ? 'check' : 'warning'} />
+          <span>{latest.message}</span>
+          {(counts.warnings || counts.errors || counts.previewOmitted) ? (
+            <small>{counts.errors || 0} errors · {counts.warnings || 0} warnings · {counts.previewOmitted || 0} previews omitted</small>
+          ) : null}
+          <SourceReceiptDetails latest={latest} />
+        </div>
+      ) : null}
+    </section>
+  );
+}
+
+export function ProgressStrip({ workspace }) {
+  const progress = workspace.discoveryProgress;
+  if (!progress?.active) return null;
+  return (
+    <div className="tx-progress-strip tx-portal-resolution-progress" role="status" aria-live="polite" data-phase={progress.phase || 'resolving'}>
+      <span>{progress.label || 'Preparing source snapshot'}</span>
+      {progress.quantified !== false && progress.percent != null ? <div className="tx-progress-bar" aria-label="Source progress"><i style={{ width: `${Math.max(0, Math.min(100, Number(progress.percent || 0)))}%` }} /></div> : <small className="tx-progress-phase">{progress.phase || 'working'}</small>}
+    </div>
+  );
+}
+
+export function WorkspaceDropHint({ workspace, hasMaterial }) {
+  if (hasMaterial || workspace.discoveryProgress) return null;
+  return (
+    <div className="tx-workspace-drop-hint" role="note">
+      <p><strong>Drop local material here</strong><span>.md, folders, or .zip · local/session only</span></p>
+    </div>
+  );
+}
+
+export function ModeToolbar({ state, query, displayOptions, selectedRecord, lineageLoadReport = null, lineageReady = false, onVerse, onQuery, onOpenDisplayOptions, onRunLineageAudit, onLoadFullLineage, readOnly = false }) {
+  const requestedVerse = state.view?.workspaceVerse || 'feed';
+  const verse = readOnly && !['feed', 'tree', 'graph'].includes(requestedVerse) ? 'feed' : requestedVerse;
+  const discoveryVerse = verse === 'feed' || verse === 'tree';
+  const graphVerse = verse === 'graph';
+  const lineageVerse = verse === 'lineage';
+  const auditVerse = verse === 'audit';
+  const selectedRecordId = String(state.view?.selectedRecordId || '');
+  const selectedLineageReport = lineageLoadReport && String(lineageLoadReport.selectedRecordId || '') === selectedRecordId ? lineageLoadReport : null;
+  const lineageAttempted = Boolean(lineageVerse && selectedRecord && (lineageReady || selectedLineageReport));
+  const lineageComplete = Boolean(lineageAttempted && (lineageReady || (selectedLineageReport && selectedLineageReport.state === 'complete' && !selectedLineageReport.hasMissing)));
+  const needsLineageLoad = Boolean(lineageVerse && selectedRecord && (!selectedLineageReport || selectedLineageReport.state !== 'complete' || selectedLineageReport.hasMissing));
+  const modeLabel = graphVerse ? 'GRAPH ORIENTATION' : lineageVerse ? 'LINEAGE MODE' : auditVerse ? 'AUDIT DETAILS' : 'DISCOVERY MODE';
+  const activeDisplayConstraintCount = displayOptionsActiveConstraintCount(displayOptions, lineageVerse ? 'lineage' : 'discovery');
+  const lineageReturnVerse = state.view?.lineageReturnVerse === 'tree' ? 'tree' : 'feed';
+  const returnVerse = auditVerse && selectedRecord ? 'lineage' : lineageVerse ? lineageReturnVerse : 'feed';
+  const canDisplayOptions = discoveryVerse || lineageAttempted;
+  const canSearch = graphVerse || !lineageVerse || lineageAttempted;
+  return (
+    <div className="tx-mode-strip tx-column-toolbar" aria-label="Mode controls">
+      <strong className="tx-mode-name">{modeLabel}</strong>
+      {discoveryVerse ? (
+        <>
+          <div className="tx-segment" aria-label="Discovery view">
+            <button type="button" className={verse === 'feed' ? 'tx-active' : ''} onClick={() => onVerse('feed')}>Feed</button>
+            <button type="button" className={verse === 'tree' ? 'tx-active' : ''} onClick={() => onVerse('tree')}>Tree</button>
+          </div>
+          <button type="button" className="tx-mode-action-button tx-mode-graph-button" onClick={() => onVerse('graph')} aria-label="Open Node Graph Verse">Graph</button>
+        </>
+      ) : (
+        <>
+          <button type="button" className="tx-mode-return" onClick={() => onVerse(returnVerse)}>← Back</button>
+          {lineageVerse && selectedRecord ? <button type="button" className="tx-mode-action-button tx-mode-graph-button" onClick={() => onVerse('graph')} aria-label="Open selected artifact in Node Graph Verse">Graph</button> : null}
+        </>
+      )}
+      {!readOnly && needsLineageLoad ? (
+        <button type="button" className="tx-mode-load-lineage-button" onClick={onLoadFullLineage} title="Load or retry the full lineage index from available source/direct transport before Audit" aria-label="Load full lineage">
+          <Icon name="lineage" /><span>Load full lineage</span>
+        </button>
+      ) : null}
+      {!readOnly && lineageComplete ? (
+        <button type="button" className="tx-mode-action-button tx-mode-audit-button tx-mode-audit-run-button" onClick={onRunLineageAudit} title="Audit lineage" aria-label="Audit lineage">
+          <Icon name="audit" /><span>Audit</span>
+        </button>
+      ) : null}
+      {canDisplayOptions ? (
+        <button type="button" className="tx-mode-action-button tx-display-options-icon-trigger" onClick={onOpenDisplayOptions} title={`Display options${activeDisplayConstraintCount ? ` · ${activeDisplayConstraintCount} active` : ''}`} aria-label={`Display options${activeDisplayConstraintCount ? `, ${activeDisplayConstraintCount} active` : ''}`}>
+          <Icon name="filters" />
+          {activeDisplayConstraintCount ? <span className="tx-mode-action-count">{activeDisplayConstraintCount}</span> : null}
+        </button>
+      ) : null}
+      {canSearch ? (
+        <label className="tx-search-field tx-search-field-icon">
+          <Icon name="search" />
+          <input value={query} onChange={(event) => onQuery(event.target.value)} type="search" placeholder={graphVerse ? 'Search graph title/schema/path…' : lineageVerse ? 'Search loaded lineage…' : 'Search title/body/schema/path…'} />
+        </label>
+      ) : null}
+    </div>
+  );
+}
+
+export function EmptyWorkspaceState({ filtered, hasMaterial, query, summary = null, progress = null }) {
+  const copy = workspaceEmptyStateCopy({ filtered, hasMaterial, query, summary, progress });
+  return (
+    <div className="tx-empty-node-state tx-compact-empty-node-state" role="status" aria-live="polite">
+      <p>{copy.message}</p>
+      {copy.hint ? <small>{copy.hint}</small> : null}
+      {copy.firstWarning?.message ? <small className="tx-empty-receipt-detail">Warning: {String(copy.firstWarning.message).slice(0, 220)}</small> : null}
+      {copy.firstError?.error ? <small className="tx-empty-receipt-detail">Error: {String(copy.firstError.error).slice(0, 220)}</small> : null}
+    </div>
+  );
+}

package/src/schemas/workspace/workspace.continuationDialog.views.jsx

@@ -0,0 +1,80 @@
+import React, { useState } from 'react';
+import { Badge } from '../../ui/primitives/Badge.jsx';
+import { Button } from '../../ui/primitives/Button.jsx';
+import { Modal } from '../../ui/primitives/Modal.jsx';
+import { createContinuationDraft, listContinuationTargets } from '@tiinex/core/transitions/record.transitions.js';
+
+export function ContinuationDialog({ record, schemaRegistry, transitionDefinition = null, workspaceRecords = [], onDismiss, onCreateTransition }) {
+  const transitionTarget = transitionDefinition ? targetFromTransitionDefinition(transitionDefinition) : null;
+  const targets = transitionTarget ? [transitionTarget] : listContinuationTargets(schemaRegistry);
+  const [selected, setSelected] = useState(targets[0]?.id || 'tiinex.task.v1');
+  const [title, setTitle] = useState(`Continue · ${record?.title || 'artifact'}`.slice(0, 96));
+  const [summary, setSummary] = useState(`Continuation leaf drafted from ${record?.title || 'this artifact'}.`.slice(0, 280));
+  const target = targets.find((item) => item.id === selected) || targets[0] || { id: 'tiinex.task.v1', label: 'Task', summary: 'Task continuation.' };
+  const draft = createContinuationDraft(record, target, { title, summary, transitionDefinitionId: transitionDefinition?.id || '', intent: transitionDefinition?.intent || 'continue' }, { existingRecords: workspaceRecords });
+  const lockedTarget = Boolean(transitionDefinition);
+  const dialogTitle = transitionDefinition?.label || 'Create continuation leaf';
+  return (
+    <Modal title={dialogTitle} onDismiss={onDismiss} initialFocus="continuationTitle">
+      <div className="tx-continuation-dialog tx-continuation-dialog-compact">
+        {!lockedTarget && targets.length > 1 ? <ContinuationTargetPicker targets={targets} selected={selected} onSelect={setSelected} /> : null}
+        <label className="tx-field"><span>Title</span><input id="continuationTitle" value={title} onChange={(event) => setTitle(event.target.value)} maxLength={96} /></label>
+        <label className="tx-field"><span>Summary</span><textarea value={summary} onChange={(event) => setSummary(event.target.value)} rows={3} maxLength={280} /></label>
+        <TransitionValidationNotice validation={draft.validation} />
+        <details className="tx-continuation-meta">
+          <summary>Generated details</summary>
+          <div className="tx-card-badges">
+            <Badge>{draft.schema}</Badge><Badge>{transitionDefinition?.presentation?.group || 'Continue'}</Badge><Badge>{target.id}</Badge><Badge>{draft.transition.parentBoundary}</Badge>
+          </div>
+          <p className="tx-muted">Creates a browser-local {target.label} draft from the selected record. Source-backed parent material stays read-only and no source provenance is inferred.</p>
+          <details className="tx-continuation-preview"><summary>Preview generated Markdown</summary><pre className="tx-record-markdown-preview">{draft.markdown}</pre></details>
+        </details>
+        <div className="tx-dialog-actions">
+          <Button variant="ghost" onClick={onDismiss}>Cancel</Button>
+          <Button variant="primary" icon={transitionDefinition?.presentation?.icon || 'continue'} onClick={() => onCreateTransition?.(record, draft)}>Create local {target.label.toLowerCase()}</Button>
+        </div>
+      </div>
+    </Modal>
+  );
+}
+
+function ContinuationTargetPicker({ targets = [], selected = '', onSelect }) {
+  return (
+    <div className="tx-continuation-target-grid" role="listbox" aria-label="Continuation target schema">
+      {targets.map((item) => <button key={item.id} type="button" className={`tx-continuation-target ${selected === item.id ? 'tx-active' : ''}`} aria-selected={selected === item.id} onClick={() => onSelect?.(item.id)}><strong>{item.label}</strong><small>{item.summary}</small></button>)}
+    </div>
+  );
+}
+
+export function TransitionValidationNotice({ validation }) {
+  if (!validation) return null;
+  const severe = (validation.findings || []).filter((finding) => finding.severity === 'error' || finding.severity === 'warning').slice(0, 3);
+  if (validation.ok && severe.length === 0) return null;
+  return (
+    <div className={`tx-transition-validation tx-transition-validation-${validation.status || (validation.ok ? 'valid' : 'invalid')}`}>
+      <strong>{validation.ok ? 'Transition conformance passed' : 'Transition conformance needs attention'}</strong>
+      <span>{validation.counts?.error || 0} errors · {validation.counts?.warning || 0} warnings · local draft boundary</span>
+      {severe.length ? <ul>{severe.map((finding) => <li key={finding.code}>{finding.message}</li>)}</ul> : null}
+    </div>
+  );
+}
+
+function targetFromTransitionDefinition(definition = {}) {
+  const resultSchema = definition.resultSchema || 'tiinex.task.v1';
+  return {
+    id: resultSchema,
+    label: definition.shortLabel || labelFromSchemaId(resultSchema),
+    summary: definition.label || 'Schema-backed continuation.',
+    contract: definition.id || '',
+    transitionDefinitionId: definition.id || '',
+    intent: definition.intent || 'continue',
+    creationContract: `creation:continue-from-record:${resultSchema}`,
+    creationStatus: 'implemented',
+    boundary: 'Transition definition creates a browser-local draft and does not mutate source material.'
+  };
+}
+
+function labelFromSchemaId(id = '') {
+  const tail = String(id || '').split('.').filter(Boolean).slice(-2, -1)[0] || String(id || 'leaf');
+  return tail.charAt(0).toUpperCase() + tail.slice(1);
+}

package/src/schemas/workspace/workspace.discovery.views.jsx

@@ -0,0 +1,63 @@
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import { AssetCard, MemoRecordCard as RecordCard } from './workspace.cards.views.jsx';
+import { discoveryInitialRecordWindowLimitForScroll, discoveryRecordWindowKey, discoveryRenderWindowProfile, discoveryWindowState, DISCOVERY_INITIAL_RECORD_WINDOW } from './workspace.discoveryRenderWindow.js';
+
+export function DiscoveryRecordList({ records = [], assets = [], auditById = new Map(), stageScrollTop = 0, actionStateKey = '', workspaceRecords = [], workspaceId = '', transitionProductContext = null, onOpenRecord, onFocusRecordLineage, onShareRecord, onRecordAction, onOpenSchema, onOpenAsset, readOnly = false, selectionActive = false, selectionCandidates = [], onSelectCandidate }) {
+  const selectionByRecordId = useMemo(() => new Map((Array.isArray(selectionCandidates) ? selectionCandidates : []).filter((item) => String(item?.workspaceId || '') === String(workspaceId) && item?.id).map((item) => [String(item.id), item])), [selectionCandidates, workspaceId]);
+  const resetKey = useMemo(() => discoveryRecordWindowKey(records, assets), [records, assets]);
+  const [viewport, setViewport] = useState(() => discoveryViewportSnapshot());
+  const profile = useMemo(() => discoveryRenderWindowProfile(viewport), [viewport]);
+  const restoreWindowLimit = useMemo(() => discoveryInitialRecordWindowLimitForScroll(stageScrollTop, viewport, profile), [stageScrollTop, viewport, profile]);
+  const [visibleRecordLimit, setVisibleRecordLimit] = useState(() => restoreWindowLimit || profile.initial || DISCOVERY_INITIAL_RECORD_WINDOW);
+  const sentinelRef = useRef(null);
+  const windowState = useMemo(() => discoveryWindowState(records, visibleRecordLimit, profile), [records, visibleRecordLimit, profile]);
+  const totalRecords = windowState.total;
+  const visibleRecords = windowState.visibleRecords;
+  const remainingRecords = windowState.remaining;
+
+  useEffect(() => {
+    setVisibleRecordLimit(Math.max(profile.initial || DISCOVERY_INITIAL_RECORD_WINDOW, restoreWindowLimit || 0));
+  }, [resetKey, profile.initial, restoreWindowLimit]);
+
+  useEffect(() => {
+    if (typeof window === 'undefined') return undefined;
+    const update = () => setViewport(discoveryViewportSnapshot());
+    window.addEventListener('resize', update, { passive: true });
+    window.visualViewport?.addEventListener?.('resize', update, { passive: true });
+    return () => {
+      window.removeEventListener('resize', update);
+      window.visualViewport?.removeEventListener?.('resize', update);
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!remainingRecords || !sentinelRef.current || typeof IntersectionObserver === 'undefined') return undefined;
+    const node = sentinelRef.current;
+    const observer = new IntersectionObserver((entries) => {
+      if (!entries.some((entry) => entry.isIntersecting)) return;
+      setVisibleRecordLimit((limit) => Math.min(totalRecords, limit + windowState.step));
+    }, { rootMargin: '540px 0px' });
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, [remainingRecords, totalRecords, windowState.step]);
+
+  return (
+    <div className="tx-discovery-record-list tx-unified-record-list" aria-label="Discovery artifacts" data-record-window={visibleRecords.length < totalRecords ? 'partial' : 'complete'}>
+      {visibleRecords.map((record) => <RecordCard key={record.id} record={record} auditItem={auditById.get(record.id)} actionStateKey={actionStateKey} workspaceRecords={workspaceRecords} workspaceId={workspaceId} transitionProductContext={transitionProductContext} readOnly={readOnly} selectionActive={selectionActive} selectionCandidate={selectionByRecordId.get(String(record.id)) || null} onSelectCandidate={onSelectCandidate} onOpenRecord={onOpenRecord} onFocusRecordLineage={onFocusRecordLineage} onShareRecord={onShareRecord} onRecordAction={onRecordAction} onOpenSchema={onOpenSchema} />)}
+      {remainingRecords ? (
+        <div className="tx-discovery-window-sentinel" ref={sentinelRef} aria-live="polite">
+          <span className="tx-discovery-window-summary">Showing {visibleRecords.length} of {totalRecords} matching artifacts. Search and filters already cover all loaded content.</span>
+          <button type="button" onClick={() => setVisibleRecordLimit((limit) => Math.min(totalRecords, limit + windowState.step))}>Load more</button>
+        </div>
+      ) : null}
+      {assets.map((asset) => <AssetCard key={asset.id || asset.path} asset={asset} actionStateKey={actionStateKey} onOpenAsset={onOpenAsset} />)}
+    </div>
+  );
+}
+
+function discoveryViewportSnapshot() {
+  if (typeof window === 'undefined') return { width: 0, coarse: false };
+  let coarse = false;
+  try { coarse = Boolean(window.matchMedia?.('(pointer: coarse)')?.matches); } catch (_) {}
+  return { width: Math.floor(window.visualViewport?.width || window.innerWidth || 0), height: Math.floor(window.visualViewport?.height || window.innerHeight || 0), coarse };
+}

package/src/schemas/workspace/workspace.discoveryRenderWindow.js

@@ -0,0 +1,56 @@
+export const DISCOVERY_INITIAL_RECORD_WINDOW = 60;
+export const DISCOVERY_RECORD_WINDOW_STEP = 40;
+export const DISCOVERY_MOBILE_INITIAL_RECORD_WINDOW = 30;
+export const DISCOVERY_MOBILE_RECORD_WINDOW_STEP = 24;
+export const DISCOVERY_DESKTOP_ESTIMATED_CARD_HEIGHT = 126;
+export const DISCOVERY_MOBILE_ESTIMATED_CARD_HEIGHT = 154;
+export const DISCOVERY_SCROLL_RESTORE_OVERSCAN_PX = 900;
+
+export function discoveryRenderWindowProfile(viewport = {}) {
+  const width = Number(viewport.width || 0);
+  const coarse = viewport.coarse === true;
+  const mobile = coarse || (width > 0 && width <= 540);
+  return Object.freeze({
+    mobile,
+    initial: mobile ? DISCOVERY_MOBILE_INITIAL_RECORD_WINDOW : DISCOVERY_INITIAL_RECORD_WINDOW,
+    step: mobile ? DISCOVERY_MOBILE_RECORD_WINDOW_STEP : DISCOVERY_RECORD_WINDOW_STEP,
+    estimatedCardHeight: mobile ? DISCOVERY_MOBILE_ESTIMATED_CARD_HEIGHT : DISCOVERY_DESKTOP_ESTIMATED_CARD_HEIGHT,
+    restoreOverscanPx: DISCOVERY_SCROLL_RESTORE_OVERSCAN_PX
+  });
+}
+
+export function discoveryInitialRecordWindowLimitForScroll(scrollTop = 0, viewport = {}, profile = discoveryRenderWindowProfile(viewport)) {
+  const initial = Math.max(1, Number(profile.initial || DISCOVERY_INITIAL_RECORD_WINDOW));
+  const top = Math.max(0, Number(scrollTop || 0));
+  if (!Number.isFinite(top) || top <= 0) return initial;
+  const viewportHeight = Math.max(0, Number(viewport.height || 0));
+  const estimate = Math.max(72, Number(profile.estimatedCardHeight || DISCOVERY_DESKTOP_ESTIMATED_CARD_HEIGHT));
+  const overscan = Math.max(0, Number(profile.restoreOverscanPx || DISCOVERY_SCROLL_RESTORE_OVERSCAN_PX));
+  const needed = Math.ceil((top + viewportHeight + overscan) / estimate);
+  return Math.max(initial, needed);
+}
+
+export function discoveryRecordWindowKey(records = [], assets = []) {
+  const first = records[0]?.id || records[0]?.path || '';
+  const last = records[records.length - 1]?.id || records[records.length - 1]?.path || '';
+  const firstAsset = assets[0]?.id || assets[0]?.path || '';
+  return `${records.length}:${first}:${last}:${assets.length}:${firstAsset}`;
+}
+
+export function discoveryWindowState(records = [], requestedLimit = 0, profile = discoveryRenderWindowProfile()) {
+  const source = Array.isArray(records) ? records : [];
+  const total = source.length;
+  const initial = Math.max(1, Number(profile.initial || DISCOVERY_INITIAL_RECORD_WINDOW));
+  const requested = Math.max(initial, Number(requestedLimit || initial));
+  const limit = total > initial ? Math.min(total, requested) : total;
+  const visibleRecords = limit < total ? source.slice(0, limit) : source;
+  return Object.freeze({
+    total,
+    visibleRecords,
+    visibleCount: visibleRecords.length,
+    remaining: Math.max(0, total - visibleRecords.length),
+    partial: visibleRecords.length < total,
+    initial,
+    step: Math.max(1, Number(profile.step || DISCOVERY_RECORD_WINDOW_STEP))
+  });
+}

package/src/schemas/workspace/workspace.displayOptions.views.jsx

@@ -0,0 +1,114 @@
+import React, { useState } from 'react';
+import { Button } from '../../ui/primitives/Button.jsx';
+import { Modal } from '../../ui/primitives/Modal.jsx';
+import { materialRoleLabel } from '@tiinex/core/workspaces/workspace.materialRole.js';
+import { normalizeWorkspaceDisplayOptions } from '../../workspaces/workspace.displayOptions.js';
+import { normalizeTimePortalView } from '../../workspaces/workspace.timePortal.js';
+
+export function DisplayOptionsDialog({ options, counts = {}, scope = 'discovery', timePortal = null, onResolveTimePortal, onReturnLatest, onSubmit, onDismiss }) {
+  const [draft, setDraft] = useState(normalizeWorkspaceDisplayOptions(options));
+  const normalizedTimePortal = normalizeTimePortalView(timePortal);
+  const [timeDraft, setTimeDraft] = useState({ begin: normalizedTimePortal?.begin || '', end: normalizedTimePortal?.end || '' });
+  const schemaChoices = Array.isArray(counts.schemaChoices) ? counts.schemaChoices : [];
+  const artifactChoices = Array.isArray(counts.artifactChoices) ? counts.artifactChoices : [];
+  const sourceChoices = Array.isArray(counts.sourceChoices) ? counts.sourceChoices : [];
+  const lineageScope = String(scope || 'discovery') === 'lineage';
+  function setFlag(key, value) {
+    setDraft((current) => Object.assign({}, current, { [key]: Boolean(value) }));
+  }
+  function setValue(key, value) {
+    setDraft((current) => Object.assign({}, current, { [key]: String(value || 'all') || 'all' }));
+  }
+  function submit(event) {
+    event.preventDefault();
+    onSubmit?.(normalizeWorkspaceDisplayOptions(draft));
+  }
+  return (
+    <Modal title="Display options" onDismiss={onDismiss} initialFocus={lineageScope ? 'displaySchemaFilter' : 'displayLeavesOnly'} className="tx-dialog-display-options">
+      <form className="tx-form tx-display-options-form tx-display-options-parity-form" onSubmit={submit} data-form="display-options-form">
+        <p className="tx-muted">{lineageScope ? 'Lineage filters apply to the loaded lineage only. Leaves-only and material membership controls are Discovery-only.' : 'Presentation only. Source, audit, lineage, and export truth stay intact even when material is filtered from Feed/Tree.'}</p>
+        <div className="tx-display-filter-grid" aria-label="Artifact filters">
+          <label className="tx-select-field">
+            <span>Schema</span>
+            <select id="displaySchemaFilter" value={draft.schemaFilter} onChange={(event) => setValue('schemaFilter', event.target.value)}>
+              <option value="all">All schemas</option>
+              {schemaChoices.map(([value, count]) => <option key={value} value={value}>{compactSchemaOption(value)} · {count}</option>)}
+            </select>
+          </label>
+          <label className="tx-select-field">
+            <span>Artifact role</span>
+            <select value={draft.artifactFilter} onChange={(event) => setValue('artifactFilter', event.target.value)}>
+              <option value="all">All roles</option>
+              {artifactChoices.map(([value, count]) => <option key={value} value={value}>{artifactFilterLabel(value)} · {count}</option>)}
+            </select>
+          </label>
+          <label className="tx-select-field">
+            <span>Source boundary</span>
+            <select value={draft.sourceFilter} onChange={(event) => setValue('sourceFilter', event.target.value)}>
+              <option value="all">All boundaries</option>
+              {sourceChoices.map(([value, count]) => <option key={value} value={value}>{sourceFilterLabel(value)} · {count}</option>)}
+            </select>
+          </label>
+        </div>
+        {!lineageScope ? (
+          <label className="tx-display-option-row tx-display-option-primary">
+            <span><strong>Leaves only</strong><small>{Number(counts.leaves || 0)} terminal work {Number(counts.leaves || 0) === 1 ? 'leaf' : 'leaves'} · hides loaded parents, schema/type definitions, support files, and body-missing source shells</small></span>
+            <input id="displayLeavesOnly" type="checkbox" checked={draft.leavesOnly} onChange={(event) => setFlag('leavesOnly', event.target.checked)} />
+          </label>
+        ) : null}
+        <label className="tx-display-option-row">
+          <span><strong>Mismatches only</strong><small>{Number(counts.mismatches || 0)} record{Number(counts.mismatches || 0) === 1 ? '' : 's'} currently carry mismatch-level audit status</small></span>
+          <input id="displayMismatchesOnly" type="checkbox" checked={draft.mismatchesOnly} onChange={(event) => setFlag('mismatchesOnly', event.target.checked)} />
+        </label>
+        {!lineageScope ? (
+          <section className="tx-display-time-portal" aria-label="Time Portal">
+            <h3>Time Portal</h3>
+            <p className="tx-muted">Source-grounded historical review. Begin/End expresses intent only; no date is converted into a commit.</p>
+            <div className="tx-display-filter-grid">
+              <label className="tx-field"><span>Begin</span><input type="datetime-local" value={timeDraft.begin} onChange={(event) => setTimeDraft((current) => Object.assign({}, current, { begin: event.target.value }))} /></label>
+              <label className="tx-field"><span>End / as-of intent</span><input type="datetime-local" value={timeDraft.end} onChange={(event) => setTimeDraft((current) => Object.assign({}, current, { end: event.target.value }))} /></label>
+            </div>
+            <div className="tx-dialog-actions tx-time-portal-inline-actions">
+              {normalizedTimePortal ? <Button type="button" variant="ghost" onClick={onReturnLatest}>Return to latest</Button> : null}
+              <Button type="button" variant="ghost" onClick={() => onResolveTimePortal?.(timeDraft)}>Resolve source snapshot</Button>
+            </div>
+          </section>
+        ) : null}
+        {!lineageScope ? (
+          <>
+            <label className="tx-display-option-row">
+              <span><strong>Supporting docs</strong><small>{Number(counts.supportingMarkdown || 0)} supporting doc{Number(counts.supportingMarkdown || 0) === 1 ? '' : 's'} · preserved but hidden by default</small></span>
+              <input id="displaySupportingMarkdown" type="checkbox" checked={draft.showSupportingMarkdown} onChange={(event) => setFlag('showSupportingMarkdown', event.target.checked)} />
+            </label>
+            <label className="tx-display-option-row">
+              <span><strong>Workspace artifacts</strong><small>{Number(counts.workspaceArtifacts || 0)} artifact{Number(counts.workspaceArtifacts || 0) === 1 ? '' : 's'} · Open/Merge remain artifact capabilities</small></span>
+              <input type="checkbox" checked={draft.showWorkspaceArtifacts} onChange={(event) => setFlag('showWorkspaceArtifacts', event.target.checked)} />
+            </label>
+            <label className="tx-display-option-row">
+              <span><strong>Assets</strong><small>{Number(counts.assets || 0)} asset{Number(counts.assets || 0) === 1 ? '' : 's'} · hidden by default, never fake leaves</small></span>
+              <input type="checkbox" checked={draft.showAssets} onChange={(event) => setFlag('showAssets', event.target.checked)} />
+            </label>
+          </>
+        ) : null}
+        <div className="tx-dialog-actions">
+          <Button type="button" variant="ghost" onClick={onDismiss}>Cancel</Button>
+          <Button type="submit" variant="primary" icon="check">Apply</Button>
+        </div>
+      </form>
+    </Modal>
+  );
+}
+
+function compactSchemaOption(value = '') {
+  return String(value || 'artifact').replace(/^tiinex\./, '').replace(/\.v\d+$/, '');
+}
+
+function artifactFilterLabel(value = '') {
+  return materialRoleLabel(value);
+}
+
+function sourceFilterLabel(value = '') {
+  if (value === 'source-backed') return 'Source-backed';
+  if (value === 'local') return 'Local/session';
+  return value || 'Source boundary';
+}