@tiinex/core 0.1.1

package/src/schemas/core/signal/tiinex.signal.v1.schema.source.js

@@ -0,0 +1,9 @@
+import binding from './tiinex.signal.v1.schema.json' with { type: 'json' };
+import projection from './tiinex.signal.v1.schema.runtime.json' with { type: 'json' };
+import { defineBundledSchemaSource } from '../../schema.source.js';
+
+export const schemaSource = defineBundledSchemaSource(binding, projection, Object.freeze({
+  bundledPath: 'src/schemas/core/signal/tiinex.signal.v1.schema.md',
+  sourceLabel: 'Viewer schema registry',
+  assetUrl: new URL('./tiinex.signal.v1.schema.md', import.meta.url).href
+}));

package/src/schemas/core/task/tiinex.task.v1.capabilities.js

@@ -0,0 +1,11 @@
+export const taskCapabilities = Object.freeze({
+  canCreateArtifact: true,
+  canBeParent: true,
+  canRenderFallback: false,
+  supportedSurfaces: ['feed', 'tree', 'detail', 'lineage', 'preview', 'share'],
+  boundaries: [
+    'browser-local-draft-task',
+    'source-backed-parent-read-only',
+    'task-draft-does-not-inherit-source-provenance'
+  ]
+});

package/src/schemas/core/task/tiinex.task.v1.contract.js

@@ -0,0 +1,3 @@
+export const TASK_CANONICAL_BODY_SECTIONS = Object.freeze(['Objective', 'Done Criteria', 'Scope', 'Dependencies']);
+export const TASK_CANONICAL_REQUIRED_INPUTS = Object.freeze(['Summary', ...TASK_CANONICAL_BODY_SECTIONS]);
+export const TASK_LEGACY_BODY_SECTIONS = Object.freeze(['Task Draft', 'Next Step', 'Source Boundary', 'Source Excerpt']);

package/src/schemas/core/task/tiinex.task.v1.en.i18n.json

@@ -0,0 +1,15 @@
+{
+  "label": "Task",
+  "summary": "Canonical Task artifact with bounded work and completion criteria.",
+  "task.schema.mismatch": "Task validator was invoked for a non-task current schema.",
+  "task.title.missing": "Task artifact should begin with a human-readable title.",
+  "task.objective.missing": "Task body is missing the required Objective section.",
+  "task.doneCriteria.missing": "Task body is missing the required Done Criteria section.",
+  "task.scope.missing": "Task body is missing the required Scope section.",
+  "task.dependencies.missing": "Task body is missing the required Dependencies section.",
+  "task.legacyShape.observed": "Task body uses legacy browser-draft sections and is not the exact current canonical Task shape.",
+  "task.body.thin": "Task body is thin; the bounded work request may be unclear.",
+  "task.body.canonical": "Task body exposes the current canonical Objective, Done Criteria, Scope, and Dependencies sections.",
+  "task.legacyShape.incomplete": "Legacy browser-draft compatibility is incomplete; required historical sections are missing.",
+  "task.legacyShape.readable": "Historical browser-local Task draft remains readable and editable through the explicit compatibility boundary."
+}

package/src/schemas/core/task/tiinex.task.v1.findings.js

@@ -0,0 +1,18 @@
+export const taskFindings = Object.freeze({
+  namespace: 'tiinex.task.v1',
+  defaultSeverity: 'info',
+  codes: Object.freeze({
+    'task.schema.mismatch': finding('task.schema.mismatch', 'warning', 'none'),
+    'task.title.missing': finding('task.title.missing', 'error', 'safe'),
+    'task.objective.missing': finding('task.objective.missing', 'error', 'manual'),
+    'task.doneCriteria.missing': finding('task.doneCriteria.missing', 'error', 'manual'),
+    'task.scope.missing': finding('task.scope.missing', 'error', 'manual'),
+    'task.dependencies.missing': finding('task.dependencies.missing', 'error', 'manual'),
+    'task.legacyShape.observed': finding('task.legacyShape.observed', 'warning', 'manual'),
+    'task.legacyShape.incomplete': finding('task.legacyShape.incomplete', 'error', 'manual'),
+    'task.legacyShape.readable': finding('task.legacyShape.readable', 'info', 'none'),
+    'task.body.thin': finding('task.body.thin', 'warning', 'manual'),
+    'task.body.canonical': finding('task.body.canonical', 'info', 'none')
+  })
+});
+function finding(messageKey, severity, fixability) { return Object.freeze({ severity, messageKey, fixability }); }

package/src/schemas/core/task/tiinex.task.v1.localMaterialization.js

@@ -0,0 +1,148 @@
+import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
+import { createRecordFromMarkdown } from '../../../artifacts/artifact.record.js';
+import { compilePortableSchemaContractChain } from '../../../tooling/portable/schema/contract.compile.js';
+import { taskValidate } from './tiinex.task.v1.validate.js';
+import { canonicalC14nV2SelfState, sealC14nV2Self } from '../../../integrity/integrity.c14nV2.js';
+import { inspectCreationRepresentation } from '../../creation.representation.js';
+import { TASK_CANONICAL_REQUIRED_INPUTS } from './tiinex.task.v1.contract.js';
+
+
+function exactRepresentationMultiplicity(representation = {}, mode = 'root') {
+  if (representation.continuityContextHeadings !== 1 || representation.currentBlocks !== 1 || representation.currentSchema?.length !== 1 || representation.createdAt?.length !== 1 || representation.summary?.length !== 1 || representation.bodyH1?.length !== 1 || representation.integrityHeadings !== 1 || representation.selfIntegrityEntries?.length !== 1) return false;
+  if (representation.parentBlocks !== (mode === 'parent' ? 1 : 0)) return false;
+  return REQUIRED_INPUTS.slice(1).every((name) => (representation.sectionBodies?.[name] || []).length === 1);
+}
+
+export const CANONICAL_TASK_LOCAL_MATERIALIZER_SCHEMA_ID = 'tiinex.site.canonical-task-local-materializer.v1';
+export const CANONICAL_TASK_SCHEMA_ID = 'tiinex.task.v1';
+const REQUIRED_INPUTS = TASK_CANONICAL_REQUIRED_INPUTS;
+
+export function renderCanonicalTaskLocalArtifact(input = {}) {
+  const values = input.values || {};
+  const parent = input.parent || null;
+  const continuityMode = input.continuityMode === 'root' ? 'root' : 'parent';
+  const parentQualified = continuityMode === 'root'
+    ? !parent
+    : Boolean(parent?.state === 'qualified' && parent?.finalized === true && String(parent?.schemaId || '').trim());
+  const createdAt = rootTimestamp(input.now instanceof Date ? input.now : new Date(input.now || Date.now()));
+  if (!parentQualified || !REQUIRED_INPUTS.every((name) => Object.prototype.hasOwnProperty.call(values, name) && values[name] !== undefined)) {
+    const reason = !parentQualified ? (continuityMode === 'root' ? 'root-parent-must-be-absent' : 'parent-reference-unavailable') : 'task-generation-input-missing';
+    return Object.freeze({ state: 'unqualified', reason, markdown: '' });
+  }
+  const summary = canonicalSummary(values.Summary);
+  const parentEnvelope = continuityMode === 'parent'
+    ? `- Parent
+  - Parent Schema: ${parent.schemaId}
+  - Trace: ${parent.trace}
+  - Origin: ${parent.origin}
+`
+    : '';
+  const unsigned = `# Continuity Context
+
+- Envelope Schema: tiinex.root.v1
+${parentEnvelope}- Current
+  - Current Schema: tiinex.task.v1
+  - Created At: ${createdAt}
+  - Summary: ${summary}
+
+---
+
+# ${summary}
+
+## Objective
+
+${canonicalSection(values.Objective)}
+
+## Done Criteria
+
+${canonicalSection(values['Done Criteria'])}
+
+## Scope
+
+${canonicalSection(values.Scope)}
+
+## Dependencies
+
+${canonicalSection(values.Dependencies)}
+
+# Continuity Integrity
+
+- sha256-base64url-c14n-v2
+  - Towards: self
+  - Value: pending
+`;
+  const sealed = sealC14nV2Self(unsigned);
+  if (sealed.state !== 'sealed') return Object.freeze({ state: 'unqualified', reason: 'canonical-task-integrity-seal-unavailable', markdown: '' });
+  return Object.freeze({ state: 'rendered', markdown: sealed.markdown, createdAt, summary, integrityValue: sealed.value });
+}
+
+export function qualifyCanonicalTaskLocalArtifact({ markdown = '', schemaMaterials = [], values = {}, parent = null, path = '', continuityMode = 'parent' } = {}) {
+  const mode = continuityMode === 'root' ? 'root' : 'parent';
+  let compiled, parsed, projection;
+  try {
+    compiled = compilePortableSchemaContractChain(schemaMaterials);
+    parsed = parseArtifactMarkdown(markdown);
+    const schemaFindings = taskValidate(parsed);
+    projection = Object.freeze({ schema: 'tiinex.site.schema-local-materialization-qualification.v1', validation: Object.freeze({ findings: Object.freeze(schemaFindings) }) });
+  } catch (_) { return Object.freeze({ state: 'invalid', reason: 'canonical-task-parse-or-compile-failed', findings: Object.freeze([]), record: null }); }
+  const errors = (projection.validation?.findings || []).filter((finding) => finding?.severity === 'error' || finding?.state === 'structurally-invalid' || finding?.state === 'contradictory');
+  const sections = sectionBodies(markdown);
+  const representation = inspectCreationRepresentation(markdown, { boundSections: REQUIRED_INPUTS.slice(1) });
+  const current = parsed.envelope?.current || {};
+  const parentEnvelope = parsed.envelope?.parent || null;
+  const exactBody = REQUIRED_INPUTS.slice(1).every((name) => sections[name] === canonicalSection(values[name]));
+  const integrity = canonicalC14nV2SelfState(markdown);
+  const parentInvariant = mode === 'root'
+    ? !parent && !declaredParentEnvelope(parentEnvelope)
+    : Boolean(parent && String(parent.schemaId || '').trim()
+      && String(parentEnvelope?.schema?.id || '') === parent.schemaId
+      && String(parentEnvelope?.trace || '') === String(parent.traceTarget || '')
+      && String(parentEnvelope?.origin || '') === String(parent.originTarget || ''));
+  const invariant = compiled.schemaId === CANONICAL_TASK_SCHEMA_ID
+    && current.schema?.id === CANONICAL_TASK_SCHEMA_ID
+    && String(current.summary || '') === canonicalSummary(values.Summary)
+    && parentInvariant
+    && /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(String(current.createdAt || ''))
+    && firstBodyHeading(markdown) === canonicalSummary(values.Summary)
+    && exactBody
+    && exactRepresentationMultiplicity(representation, mode)
+    && integrity.state === 'verified';
+  if (errors.length || !invariant) return Object.freeze({ state: 'invalid', reason: errors.length ? 'canonical-task-contract-errors' : 'canonical-task-invariant-mismatch', findings: Object.freeze(errors), record: null, projection });
+  const record = Object.assign(createRecordFromMarkdown(markdown, { path, name: canonicalSummary(values.Summary), sourceMode: 'local-transition-canonical' }), {
+    kind: CANONICAL_TASK_SCHEMA_ID,
+    schemaId: CANONICAL_TASK_SCHEMA_ID,
+    status: 'local',
+    sourceMode: 'local-transition-canonical',
+    path,
+    hasContinuityContext: true,
+    hasIntegrity: true
+  });
+  return Object.freeze({ state: 'qualified', reason: '', findings: Object.freeze(errors), record, projection });
+}
+
+export function canonicalTaskRequiredInputs() { return REQUIRED_INPUTS; }
+function rootTimestamp(date) { return date.toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, ''); }
+function scalar(value) { return String(value === null ? '' : value ?? ''); }
+function canonicalSummary(value) { return scalar(value).trim(); }
+function canonicalSection(value) { return scalar(value).trimEnd(); }
+function declaredParentEnvelope(parent = null) { return Boolean(parent && (String(parent.schema?.id || '').trim() || String(parent.trace || '').trim() || String(parent.origin || '').trim() || String(parent.createdAt || '').trim())); }
+function firstBodyHeading(markdown) { return String(markdown).split('\n---\n')[1]?.match(/^#\s+(.+)$/m)?.[1]?.trim() || ''; }
+function sectionBodies(markdown) {
+  const body = String(markdown).split('\n---\n')[1] || '';
+  const names = REQUIRED_INPUTS.slice(1);
+  const out = {};
+  for (const name of names) {
+    const match = body.match(new RegExp(`^## ${escapeRegExp(name)}\\n\\n([\\s\\S]*?)(?=\\n\\n## |\\n\\n# Continuity Integrity|$)`, 'm'));
+    out[name] = match ? match[1].trimEnd() : undefined;
+  }
+  return out;
+}
+function escapeRegExp(value) { return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+export const taskLocalMaterialization = Object.freeze({
+  schemaId: CANONICAL_TASK_SCHEMA_ID,
+  label: 'Task',
+  render: renderCanonicalTaskLocalArtifact,
+  qualify: qualifyCanonicalTaskLocalArtifact,
+  implementation: Object.freeze({ kind: 'browser-local-artifact-representation', status: 'implemented' })
+});

package/src/schemas/core/task/tiinex.task.v1.presenter.js

@@ -0,0 +1,8 @@
+export function taskPresent(artifact, context = {}) {
+  return {
+    title: artifact?.title || 'Task',
+    summary: artifact?.summary || 'Canonical Task artifact.',
+    badges: ['concrete', 'tiinex.task.v1'],
+    disclosure: context.degraded ? 'degraded' : 'normal'
+  };
+}

package/src/schemas/core/task/tiinex.task.v1.schema.js

@@ -0,0 +1,35 @@
+import { defineSchemaModule } from '../../contracts.js';
+import { genericArtifactCreationImplementation } from '../../creation.renderer.js';
+import { defineArtifactCreationCapability } from '../../creation.capability.js';
+import { taskLocalMaterialization } from './tiinex.task.v1.localMaterialization.js';
+import binding from './tiinex.task.v1.schema.json' with { type: 'json' };
+import { schemaSource } from './tiinex.task.v1.schema.source.js';
+import { taskCapabilities } from './tiinex.task.v1.capabilities.js';
+import { taskValidate } from './tiinex.task.v1.validate.js';
+import { taskPresent } from './tiinex.task.v1.presenter.js';
+import { taskTransitions } from './tiinex.task.v1.transitions.js';
+import taskI18nEn from './tiinex.task.v1.en.i18n.json' with { type: 'json' };
+import taskI18nSv from './tiinex.task.v1.sv.i18n.json' with { type: 'json' };
+import { taskFindings } from './tiinex.task.v1.findings.js';
+import { TASK_CANONICAL_BODY_SECTIONS } from './tiinex.task.v1.contract.js';
+
+export const taskSchemaModule = defineSchemaModule({
+  id: 'tiinex.task.v1',
+  label: 'Task',
+  kind: 'concrete',
+  role: 'core-artifact',
+  parentSchemaId: 'tiinex.root.v1',
+  summary: 'Canonical Task artifacts with bounded work, completion criteria, scope, and dependencies.',
+  binding,
+  schemaSource,
+  artifactCreation: defineArtifactCreationCapability(binding, Object.freeze({ ...genericArtifactCreationImplementation, transitionTypes: Object.freeze(['create-artifact','continue-from-record']) })),
+  capabilities: taskCapabilities,
+  validate: taskValidate,
+  present: taskPresent,
+  read: Object.freeze({ label: 'Task', sections: TASK_CANONICAL_BODY_SECTIONS }),
+  viewActions: Object.freeze({ lineage: Object.freeze(['record.open', 'record.markdown', 'record.source']) }),
+  transitions: taskTransitions,
+  localMaterialization: taskLocalMaterialization,
+  i18n: Object.freeze({ en: taskI18nEn, sv: taskI18nSv }),
+  findings: taskFindings
+});

package/src/schemas/core/task/tiinex.task.v1.schema.json

@@ -0,0 +1,23 @@
+{
+  "schemaId": "tiinex.task.v1",
+  "kind": "concrete",
+  "role": "core-task-artifact",
+  "module": "./tiinex.task.v1.schema.js",
+  "snapshot": "./tiinex.task.v1.schema.md",
+  "canonicalUri": "tiinex://schemas/core/task/tiinex.task.v1",
+  "permalink": "https://github.com/Tiinex/docs/blob/053d46ce082d4ec261b82abc44ecca403d61e240/.topics/.schemas/core/task/tiinex.task.v1.schema.md",
+  "rawUrl": "https://raw.githubusercontent.com/Tiinex/docs/053d46ce082d4ec261b82abc44ecca403d61e240/.topics/.schemas/core/task/tiinex.task.v1.schema.md",
+  "sourcePath": ".topics/.schemas/core/task/tiinex.task.v1.schema.md",
+  "sourceRepository": "Tiinex/docs",
+  "sourceCommit": "053d46ce082d4ec261b82abc44ecca403d61e240",
+  "sourceBlobSha": "e4d545ad45382a150351ead587339d8b43cc0fb2",
+  "originId": "tiinex-docs-053d46ce",
+  "originTrustRole": "canonical-core",
+  "checksum": {
+    "algorithm": "sha256",
+    "value": "ff26811ac5c4393bc6b69d652f0b9fcdb38c2bdc9688dccb0b42608cbef07a98"
+  },
+  "capabilityContract": "tiinex.schema.module.v1",
+  "snapshotCompleteness": "exact-canonical-docs-snapshot",
+  "bindingVersion": "tiinex.web.schema-binding.v1"
+}