@undefineds.co/models 0.2.26 → 0.2.28

package/dist/task.schema.js

@@ -0,0 +1,49 @@
+import { id, integer, object, podTable, string, timestamp, uri } from '@undefineds.co/drizzle-solid';
+import { DCTerms, UDFS } from './namespaces.js';
+import { threadResource } from './thread.schema.js';
+import { taskResourceId } from './resource-id-defaults.js';
+export const TaskStatus = {
+    ACTIVE: 'active',
+    PAUSED: 'paused',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+};
+export const TaskTriggerKind = {
+    ONCE: 'once',
+    INTERVAL: 'interval',
+    CRON: 'cron',
+    EVENT: 'event',
+};
+/**
+ * Task resource.
+ *
+ * Task is a durable task-style command, parallel to Chat as a command surface.
+ * It is intentionally generic: protocol-specific request, response, and event
+ * shapes stay in adapter code.
+ */
+export const taskResource = podTable('task', {
+    id: id('id').default(taskResourceId),
+    surfaceId: string('surfaceId').predicate(UDFS.surfaceId).notNull().default('default'),
+    title: string('title').predicate(DCTerms.title),
+    prompt: string('prompt').predicate(UDFS.prompt).notNull(),
+    thread: uri('thread').predicate(UDFS.inThread).link(threadResource),
+    workspace: uri('workspace').predicate(UDFS.workspace).notNull(),
+    runner: string('runner').predicate(UDFS.runner).notNull(),
+    status: string('status').predicate(UDFS.status).notNull().default(TaskStatus.ACTIVE),
+    triggerKind: string('triggerKind').predicate(UDFS.triggerKind).notNull().default(TaskTriggerKind.ONCE),
+    cron: string('cron').predicate(UDFS.cron),
+    intervalSeconds: integer('intervalSeconds').predicate(UDFS.intervalSeconds),
+    eventName: string('eventName').predicate(UDFS.eventName),
+    nextRunAt: timestamp('nextRunAt').predicate(UDFS.nextRunAt),
+    lastRunAt: timestamp('lastRunAt').predicate(UDFS.lastRunAt),
+    metadata: object('metadata').predicate(UDFS.metadata),
+    createdAt: timestamp('createdAt').predicate(DCTerms.created).notNull().defaultNow(),
+    updatedAt: timestamp('updatedAt').predicate(DCTerms.modified).notNull().defaultNow(),
+}, {
+    base: '/.data/task/',
+    sparqlEndpoint: '/.data/task/-/sparql',
+    type: UDFS.Task,
+    namespace: UDFS,
+});
+// Compatibility alias. New model code should prefer `taskResource`.
+export const taskTable = taskResource;

package/dist/thread.repository.d.ts

@@ -1,7 +1,10 @@
 export declare const threadRepository: import("@undefineds.co/drizzle-solid/dist/core/repository").PodRepositoryDescriptor<import("@undefineds.co/drizzle-solid/dist/core/schema").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema").ResolvedColumns<{
     id: import("@undefineds.co/drizzle-solid/dist/core/schema").PodStringColumn<false, false>;
-    chat: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    commandKind: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    surfaceId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    chat: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
     title: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    status: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
     starred: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
     workspace: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
     metadata: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"object", null, false, false>;
@@ -9,17 +12,23 @@ export declare const threadRepository: import("@undefineds.co/drizzle-solid/dist
     updatedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
 }>>, {
     id: string;
+    commandKind: string;
+    surfaceId: string;
     chat: string;
     title: string;
+    status: string;
     starred: boolean;
     workspace: string;
     metadata: Record<string, unknown>;
     createdAt: Date;
     updatedAt: Date;
 }, {
-    chat: string;
     id?: string | undefined;
+    commandKind?: string | undefined;
+    surfaceId?: string | undefined;
+    chat?: string | undefined;
     title?: string | undefined;
+    status?: string | undefined;
     starred?: boolean | undefined;
     workspace?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
@@ -27,8 +36,11 @@ export declare const threadRepository: import("@undefineds.co/drizzle-solid/dist
     updatedAt?: Date | undefined;
 }, {
     id?: string | null | undefined;
-    chat?: string | undefined;
+    commandKind?: string | undefined;
+    surfaceId?: string | undefined;
+    chat?: string | null | undefined;
     title?: string | null | undefined;
+    status?: string | undefined;
     starred?: boolean | null | undefined;
     workspace?: string | null | undefined;
     metadata?: Record<string, unknown> | null | undefined;

package/dist/thread.schema.d.ts

@@ -1,3 +1,9 @@
+export type ThreadStatusType = 'active' | 'locked' | 'closed';
+export declare const ThreadStatus: {
+    readonly ACTIVE: "active";
+    readonly LOCKED: "locked";
+    readonly CLOSED: "closed";
+};
 /**
  * Thread resource.
  *
@@ -22,8 +28,11 @@
  */
 export declare const threadResource: import("@undefineds.co/drizzle-solid/dist/core/schema").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema").ResolvedColumns<{
     id: import("@undefineds.co/drizzle-solid/dist/core/schema").PodStringColumn<false, false>;
-    chat: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    commandKind: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    surfaceId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    chat: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
     title: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    status: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
     starred: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
     workspace: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
     metadata: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"object", null, false, false>;
@@ -32,8 +41,11 @@ export declare const threadResource: import("@undefineds.co/drizzle-solid/dist/c
 }>>;
 export declare const threadTable: import("@undefineds.co/drizzle-solid/dist/core/schema").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema").ResolvedColumns<{
     id: import("@undefineds.co/drizzle-solid/dist/core/schema").PodStringColumn<false, false>;
-    chat: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    commandKind: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    surfaceId: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    chat: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
     title: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    status: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
     starred: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"boolean", null, false, true>;
     workspace: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
     metadata: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"object", null, false, false>;

package/dist/thread.schema.js

@@ -1,6 +1,12 @@
 import { uri, boolean, object, podTable, string, timestamp, id } from '@undefineds.co/drizzle-solid';
 import { UDFS, DCTerms, SIOC } from './namespaces.js';
 import { chatResource } from './chat.schema.js';
+import { threadResourceId } from './resource-id-defaults.js';
+export const ThreadStatus = {
+    ACTIVE: 'active',
+    LOCKED: 'locked',
+    CLOSED: 'closed',
+};
 /**
  * Thread resource.
  *
@@ -24,11 +30,14 @@ import { chatResource } from './chat.schema.js';
  *   container URI here and store portable metadata with that container/resource.
  */
 export const threadResource = podTable('thread', {
-    id: id('id'),
+    id: id('id').default(threadResourceId),
+    commandKind: string('commandKind').predicate(UDFS.commandKind).notNull().default('chat'),
+    surfaceId: string('surfaceId').predicate(UDFS.surfaceId).notNull().default('default'),
     // Belongs to chat/counterpart. Stored as an RDF URI; short ids are resolved via chatResource's URI template by the ORM.
-    chat: uri('chat').predicate(SIOC.has_parent).notNull().link(chatResource),
+    chat: uri('chat').predicate(SIOC.has_parent).link(chatResource),
     // Display / state
     title: string('title').predicate(DCTerms.title),
+    status: string('status').predicate(UDFS.status).notNull().default(ThreadStatus.ACTIVE),
     starred: boolean('starred').predicate(UDFS.favorite).default(false),
     // Storage-layer execution context reference: container/resource URI
     workspace: uri('workspace').predicate(UDFS.workspace),
@@ -37,11 +46,10 @@ export const threadResource = podTable('thread', {
     createdAt: timestamp('createdAt').predicate(DCTerms.created).notNull().defaultNow(),
     updatedAt: timestamp('updatedAt').predicate(DCTerms.modified).notNull().defaultNow(),
 }, {
-    base: '/.data/chat/',
-    sparqlEndpoint: '/.data/chat/-/sparql',
+    base: '/.data/',
+    sparqlEndpoint: '/.data/-/sparql',
     type: SIOC.Thread,
     namespace: UDFS,
-    subjectTemplate: '{chat|id}/index.ttl#{id}',
 });
 // Compatibility alias. New model code should prefer `threadResource`.
 export const threadTable = threadResource;

package/package.json

@@ -1,10 +1,26 @@
 {
   "name": "@undefineds.co/models",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "keywords": [
+    "pi-package",
+    "solid",
+    "rdf",
+    "pod",
+    "drizzle-solid",
+    "models"
+  ],
+  "pi": {
+    "skills": [
+      "./skills"
+    ]
+  },
+  "bin": {
+    "udfs": "./dist/bin/udfs.js"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/undefinedsco/models.git"
@@ -60,15 +76,17 @@
     "build": "tsc -p tsconfig.json && node scripts/fix-dist-esm.mjs",
     "lint": "echo \"lint not configured\"",
     "pack:release": "node scripts/pack-release.mjs",
+    "skills:check": "node scripts/check-skills.mjs",
+    "skills:pack": "yarn skills:check && node scripts/pack-skills.mjs",
     "sync:discovery:vercel": "node --experimental-strip-types scripts/sync-discovery-vercel.ts",
     "test": "vitest run",
-    "test:ci": "vitest run tests/ai-config.test.ts tests/ai-runtime-schema.test.ts tests/client.test.ts tests/contracts-chat-contact.contract.test.ts tests/discovery-vercel.test.ts tests/discovery.test.ts tests/issue-schema.test.ts tests/profile.test.ts tests/repository.test.ts tests/resource-utils.test.ts tests/session-schema.test.ts tests/sidecar-events.contract.test.ts tests/resource-schema.test.ts",
+    "test:ci": "vitest run tests/ai-config.test.ts tests/ai-runtime-schema.test.ts tests/client.test.ts tests/contracts-chat-contact.contract.test.ts tests/discovery-vercel.test.ts tests/discovery.test.ts tests/issue-schema.test.ts tests/profile.test.ts tests/repository.test.ts tests/resource-utils.test.ts tests/session-schema.test.ts tests/sidecar-events.contract.test.ts tests/resource-schema.test.ts tests/resource-id-defaults.test.ts tests/pod-storage-descriptor.test.ts tests/udfs-cli.test.ts",
     "test:pod": "dotenv -e ../linx-models/.env -- vitest run tests/pod.integration.test.ts"
   },
   "dependencies": {
     "@comunica/query-sparql-solid": "^4.0.2",
     "@inrupt/vocab-common-rdf": "^1.0.5",
-    "@undefineds.co/drizzle-solid": "^0.3.12",
+    "@undefineds.co/drizzle-solid": "^0.3.13",
     "n3": "^1.26.0",
     "zod": "^3.22.4"
   },
@@ -77,9 +95,13 @@
     "typescript": "^5.4.0",
     "vitest": "^1.6.0"
   },
+  "peerDependencies": {
+    "@undefineds.co/drizzle-solid": "^0.3.13"
+  },
   "packageManager": "yarn@1.22.22",
   "files": [
     "dist",
+    "skills",
     "README.md",
     "package.json"
   ],

package/skills/README.md

@@ -0,0 +1,41 @@
+# Models Skills
+
+This directory contains shared modeling skills owned by `@undefineds.co/models`.
+
+`models` owns reusable Solid/RDF resource semantics for LinX, Xpod, and other
+Pod-facing shells. Product shells should consume these skills and model
+resources instead of keeping private copies of durable Pod modeling rules.
+
+Current public skills:
+
+- `solid-modeling` - shared Solid Pod, RDF, drizzle-solid, and resource-schema
+  modeling guidance.
+
+Release automation validates this directory and packages:
+
+- a generic skill archive for tools that understand `SKILL.md`
+- a Codex plugin archive that contains the same skill source
+- a Claude Code plugin archive that contains the same skill source
+
+The publish workflow uploads those artifacts to the GitHub Release for the
+version tag. It does not directly submit entries to Codex Marketplace or Claude
+Code Marketplace.
+
+Codex users can install the skill from the repository path once these files are
+on `main`:
+
+```bash
+npx codex-marketplace add undefinedsco/models/skills/solid-modeling --skill --global
+```
+
+Pi users can install the same skill through the package manifest:
+
+```bash
+pi install npm:@undefineds.co/models
+```
+
+The npm package includes `skills/` and declares `pi.skills` in `package.json`,
+so Pi discovers `skills/solid-modeling/SKILL.md` as a package skill.
+
+Marketplace-specific submission steps should be added only when the target
+platform has a documented publishing API or CLI.

package/skills/solid-modeling/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: solid-modeling
+description: Use when designing or reviewing shared Solid Pod, RDF, Linked Data, drizzle-solid, or @undefineds.co/models schemas; especially for URI vs id fields, default id functions, inverse links, chat/thread/message/task/run modeling, Pod persistence boundaries, and cross-app data semantics.
+---
+
+# Solid Modeling
+
+Use this skill when changing or reviewing shared Pod data models, RDF vocab
+mappings, drizzle-solid schemas, repositories, or tests that assert durable
+cross-app semantics.
+
+## Core Stance
+
+Model the Pod as a Linked Data graph, not as a relational database with foreign
+keys.
+
+- Use RDF/Pod relation fields for URI references.
+- Use local ids only for UI state, runtime protocol keys, function parameters,
+  or the random key passed into an id default function.
+- Treat durable `id` values as base-relative resource ids. If the storage path
+  or fragment is part of identity, the `id` must include it.
+- Do not let a field named `xxxId` secretly behave like an RDF link.
+- Prefer semantic relation names: `chat`, `thread`, `message`, `maker`,
+  `replyTo`, `workspace`, `task`, `run`, `agent`.
+- UI-only state stays outside the Pod. Durable shared state belongs in the Pod.
+
+## Package Ownership
+
+`@undefineds.co/models` owns durable shared model semantics. `drizzle-solid`
+owns the ORM/resource machinery. Product shells such as Xpod, LinX desktop,
+CLI, mobile, or workers should not duplicate shared schemas.
+
+- If a resource/schema/repository already exists in `models`, consume it.
+- If a product needs a missing shared query, mutation, or id helper, add it to
+  `models` first with tests, then call it from the product shell.
+- Keep product shells focused on interaction and adapter code: routing,
+  rendering, runtime protocol projection, local cache plumbing, and mapping
+  native runtime events into shared DTOs.
+- Do not copy shared predicates, subject/id defaults, Turtle serializers, URI
+  builders, or resource lifecycle state machines into shells.
+
+## ORM-First Pod Access
+
+Do not hand-parse shared business TTL when a resource schema exists.
+
+- Use `db.select().from(resource).where(...)` for list/subset reads.
+- Use `db.findById`, `db.updateById`, and `db.deleteById` when callers hold a
+  canonical base-relative resource id.
+- Use `db.findByIri`, `db.updateByIri`, and `db.deleteByIri` when the concrete
+  resource IRI is known.
+- Use `db.findByResource`, `db.updateByResource`, and `db.deleteByResource`
+  only at adapter boundaries that intentionally accept mixed exact targets.
+- Do not expose locator-shaped inputs in business APIs. `findByLocator`,
+  `updateByLocator`, and `deleteByLocator` are legacy compatibility surfaces.
+- Raw Solid client or `fetch` access is acceptable only for protocol-level
+  adapters where no shared business resource exists yet.
+
+## Ids, Defaults, and Subject Templates
+
+The durable `id` is base-relative. It is not a fragment id.
+
+Use an `id.default((key, row) => ...)` function when the id shape depends on
+related resources, dates, command kind, workspace, or other row values. The
+function should return the full base-relative resource id.
+
+Examples:
+
+```ts
+chatResourceId('default') === 'default/index.ttl#this'
+messageResourceId('msg_1', row) === 'chat/default/2026/05/18/messages.ttl#msg_1'
+runResourceId('run_1', row) === 'task/secretary/2026/05/18/runs.ttl#run_1'
+```
+
+Do not combine a full id default with a `subjectTemplate` that reparses or
+wraps the same id. Exact ids should resolve directly against `base`.
+
+Keep `subjectTemplate` only for simple resources where the id field is the
+stable storage key and the template has no hidden dependency on another
+resource. Prefer a default id function once the template needs parent paths,
+date buckets, fragments, or associated resource ids.
+
+If a user passes an explicit id, treat it as exact. Do not reinterpret it as a
+random key or fragment id.
+
+## URI Fields and Query Ergonomics
+
+Schema storage semantics and app ergonomics are different layers.
+
+### Pod Schema Layer
+
+Use full URI relation fields:
+
+```ts
+message.chat
+message.thread
+message.replyTo
+thread.chat
+run.thread
+run.task
+```
+
+Avoid persisted relation fields such as:
+
+```ts
+message.chatId
+message.threadId
+thread.chatId
+```
+
+unless they are intentionally opaque literal protocol fields, not RDF links.
+
+### Repository/API Layer
+
+Short-id helpers are fine at API boundaries:
+
+```ts
+messageRepository.listByThreadId(db, { chatId, threadId })
+threadRepository.listByChatId(db, { chatId })
+```
+
+These helpers should derive canonical Pod IRIs or base-relative ids internally.
+Do not force UI/CLI callers to manually construct Pod IRIs in every query.
+
+## Chat, Task, Thread, Message, Run, Step
+
+Use these concepts consistently across products:
+
+- `Chat`: interactive command surface/counterpart. It answers who or what the
+  user is talking with.
+- `Task`: task-style command surface, parallel to Chat. It describes recurring,
+  triggered, or one-off task intent.
+- `Thread`: concrete timeline/place under a Chat or Task.
+- `Message`: human/runtime communication item in a Thread, linked to the Chat
+  or Task surface when useful.
+- `Run`: one concrete execution attempt by an Agent Runtime.
+- `RunStep`: append-only execution facts for a Run.
+
+Chat and Task are command surfaces. Run is the state center for execution.
+RunStep is not a separate event store elsewhere; store it with Run when the
+storage layout is date-bucketed.
+
+## Solid Chat Relationship Guidance
+
+Align with graph semantics:
+
+| Concept | Preferred RDF direction | Typical predicate |
+|---|---|---|
+| chat contains message | `chat -> message` | `wf:message` / project vocabulary |
+| thread contains message | `thread -> message` | `sioc:has_member` or equivalent |
+| reply points to original | `replyMessage -> originalMessage` | `sioc:has_reply` / project predicate |
+| author/maker | `message -> maker` | `foaf:maker` |
+
+When inverse predicates are supported, use them for read/write symmetry. If the
+ORM cannot safely express the inverse write, put the relation writer in the
+repository and cover it with integration tests.
+
+## Resource Naming
+
+Use `Resource` names for shared models.
+
+- Export `chatResource`, `messageResource`, `taskResource`, `runResource`.
+- Keep `chatTable`-style aliases only for compatibility while downstream code
+  migrates.
+- New shared-model code should prefer `solidResources` over table registries.
+
+## Testing Expectations
+
+For shared schema changes, verify both ergonomics and graph semantics:
+
+1. Unit tests for id/default helpers and URI builders.
+2. Resource tests that assert exact-id mode or the intended `subjectTemplate`.
+3. Repository or Pod integration tests for relation read/write behavior.
+4. Assertions that produced IRIs contain no unresolved template placeholders.
+
+Do not preserve obsolete tests that encode abandoned storage paths. Rewrite
+them around current Pod semantics.
+
+## Product Boundary
+
+Product-specific domain rules do not belong in this skill.
+
+- Put product data semantics in owning schemas, repositories, and shared docs.
+- Keep this skill limited to reusable Solid/RDF modeling guidance.
+- If product terms such as `chat`, `task`, `run`, or `agent` become shared,
+  encode the durable semantics in `models`.

package/skills/solid-modeling/agents/openai.yaml

@@ -0,0 +1,6 @@
+interface:
+  display_name: "Solid Modeling"
+  short_description: "Design shared Solid/RDF model schemas"
+  default_prompt: "Use $solid-modeling to review this shared Pod schema for RDF links, id defaults, and resource ownership."
+policy:
+  allow_implicit_invocation: true